#LyX 2.3 created this file. For more info see http://www.lyx.org/
\lyxformat 544
\begin_document
\begin_header
\save_transient_properties true
\origin unavailable
\textclass report
\use_default_options true
\maintain_unincluded_children false
\language english
\language_package default
\inputencoding auto
\fontencoding global
\font_roman "times" "default"
\font_sans "default" "default"
\font_typewriter "default" "default"
\font_math "auto" "auto"
\font_default_family default
\use_non_tex_fonts false
\font_sc false
\font_osf false
\font_sf_scale 100 100
\font_tt_scale 100 100
\use_microtype false
\use_dash_ligatures true
\graphics default
\default_output_format default
\output_sync 0
\bibtex_command default
\index_command default
\paperfontsize default
\spacing single
\use_hyperref false
\papersize default
\use_geometry false
\use_package amsmath 1
\use_package amssymb 1
\use_package cancel 1
\use_package esint 1
\use_package mathdots 1
\use_package mathtools 1
\use_package mhchem 1
\use_package stackrel 1
\use_package stmaryrd 1
\use_package undertilde 1
\cite_engine basic
\cite_engine_type default
\biblio_style plain
\use_bibtopic false
\use_indices false
\paperorientation portrait
\suppress_date false
\justification true
\use_refstyle 1
\use_minted 0
\index Index
\shortcut idx
\color #008000
\end_index
\secnumdepth 3
\tocdepth 3
\paragraph_separation indent
\paragraph_indentation default
\is_math_indent 0
\math_numbering_side default
\quotes_style english
\dynamic_quotes 0
\papercolumns 1
\papersides 1
\paperpagestyle default
\tracking_changes false
\output_changes false
\html_math_output 0
\html_css_as_file 0
\html_be_strict false
\end_header

\begin_body

\begin_layout Title
The Shlaer-Mellor Metamodel
\end_layout

\begin_layout Author
Lee W.
 Riemenschneider
\end_layout

\begin_layout Abstract
A metamodel is a model of a model.
 The metamodel provides the rules and constraints of modeling using a particular
 paradigm.
 This metamodel concerns the rules and constraints of the Shlaer-Mellor
 method, so it is a Shlaer-Mellor metamodel.
 Ideally, there should only be one Shlaer-Mellor Metamodel, but consensus
 hasn't been reached by Shlaer-Mellor modeling experts, so this report tries
 to justify the reasons for this metamodel to be the best candidate for
 the title, 
\emph on
The Shlaer-Mellor Metamodel
\emph default
.
\end_layout

\begin_layout Part
The Shlaer-Mellor Metamodel Domain
\end_layout

\begin_layout Chapter
Aspects of a Metamodel Model
\end_layout

\begin_layout Standard
A metamodel is a model of a model.
 The metamodel provides the rules and constraints of modeling using a particular
 paradigm.
\end_layout

\begin_layout Standard
The metamodel provides no guidance outside of its subject matter.
 e.g., the Shlaer-Mellor metamodel provides rules and constraints for modeling
 using the Shlaer-Mellor method, but it doesn't provides rules and constraints
 concerning the representation of the modeling elements.
 This allows the modeling to be done using any notation (graphical or text)
 that can unambiguously represent the elements used in the modeling.
 It also means that the metamodel also doesn't say how the model is to be
 used.
 i.e., how it is transformed to machine language, or how it might be run in
 simulation.
\end_layout

\begin_layout Standard
A metamodel is used to describe the rules for constructing a model.
 It specifies the construction elements and the constraints on the construction
 elements.
 It is the modeled depiction of the modeling method, often done using the
 modeling method.
 
\end_layout

\begin_layout Standard
The metamodel for Shlaer-Mellor modeling has the perspective of a single
 domain model.
 All other domains are viewed only as outgoing bridges requiring outside
 servicing.
 All accesses to the domain are viewed as incoming bridges that evoke actions
 within the domain model.
 Therefore, an instance of metamodel should only be used for verifying a
 single domain model at a time.
\end_layout

\begin_layout Standard
The Shlaer-Mellor Metamodel domain is partitioned into subsystems of closely
 related objects.
 This partitioning makes the domain easier to manage, but all the objects
 belong to the subject matter of Shlaer-Mellor domain modeling.
\end_layout

\begin_layout Chapter
The Data Subsystem
\end_layout

\begin_layout Standard
The subsystem of the domain model concerned with data usage.
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Data-Package Diagram.png
	width 70page%

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Data Subsystem Diagram
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Section
Object and Attribute Descriptions
\end_layout

\begin_layout Subsection
Accessor Instance
\end_layout

\begin_layout Standard
An accessor instance is instantiated in a process model to represent the
 accessor at that point of access.
 
\end_layout

\begin_layout Standard
An instantiation is needed so the accessor can be represented with different
 parameter data sets at different places in the process model or within
 different process models in the domain.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
accessor_name:R640
\end_layout

\begin_layout Description
type_name:R422
\end_layout

\begin_layout Description
*id:R629
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select many prns related by self->PRN[R647];
\end_layout

\begin_layout Plain Layout

for each prn in prns
\end_layout

\begin_layout Plain Layout

	prn.delete();
\end_layout

\begin_layout Plain Layout

	delete object instance prn;
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\begin_layout Plain Layout

select one ins related by self->INS[R648];
\end_layout

\begin_layout Plain Layout

if (not empty ins)
\end_layout

\begin_layout Plain Layout

	select one min related by self->MIN[R648];
\end_layout

\begin_layout Plain Layout

	unrelate self from ins across R648 using min;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

select one val related by self->VAL[R629];
\end_layout

\begin_layout Plain Layout

unrelate self from val across R629;
\end_layout

\begin_layout Plain Layout

select one dus related by val->DUS[R624];
\end_layout

\begin_layout Plain Layout

unrelate val from dus across R624;
\end_layout

\begin_layout Plain Layout

delete object instance val;
\end_layout

\begin_layout Plain Layout

dus.delete();
\end_layout

\begin_layout Plain Layout

delete object instance dus;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Accessor Instance:delete()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one re related by self->VAL[R629]->DUS[R624]->RE[R514];
\end_layout

\begin_layout Plain Layout

select any pro from instances of PRO where (selected.action_id == param.actionId)
 and (selected.ordinal_position == param.ordinalPosition);
\end_layout

\begin_layout Plain Layout

create object instance ela of ELA;
\end_layout

\begin_layout Plain Layout

relate re to pro across R502 using ela;
\end_layout

\begin_layout Plain Layout

select many prns related by self->PRN[R647];
\end_layout

\begin_layout Plain Layout

for each prn in prns
\end_layout

\begin_layout Plain Layout

	prn.addToProcessModel( actionId:param.actionId, ordinalPosition:param.ordinalPosit
ion );
\end_layout

\begin_layout Plain Layout

end for; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Accessor Instance:addToProcessModel()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Attribute Instance
\end_layout

\begin_layout Standard
An attribute instance models the usage of a non-referential attribute in
 the process models.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
object_id:R643
\end_layout

\begin_layout Description
attribute_name:R642
\end_layout

\begin_layout Description
*id:R626
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one nra related by self->NRA[R642];
\end_layout

\begin_layout Plain Layout

unrelate self from nra across R642;
\end_layout

\begin_layout Plain Layout

select one ins related by self->INS[R643];
\end_layout

\begin_layout Plain Layout

if (not empty ins)
\end_layout

\begin_layout Plain Layout

	unrelate self from ins across R643;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

select one var related by self->VAR[R626];
\end_layout

\begin_layout Plain Layout

unrelate self from var across R626;
\end_layout

\begin_layout Plain Layout

select one val related by var->VAL[R635];
\end_layout

\begin_layout Plain Layout

unrelate var from val across R635;
\end_layout

\begin_layout Plain Layout

select one dus related by var->DUS[R624];
\end_layout

\begin_layout Plain Layout

unrelate var from dus across R624;
\end_layout

\begin_layout Plain Layout

delete object instance var;
\end_layout

\begin_layout Plain Layout

dus.delete();
\end_layout

\begin_layout Plain Layout

delete object instance dus; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Attribute Instance:delete()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Data Usage
\end_layout

\begin_layout Standard
Data is used in Shlaer-Mellor via variable or value accesses.
 Data is always typed.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id A unique identifier for the data usage.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

reference_id:R514
\end_layout

\begin_layout Description
type_name:R625
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one type related by self->TYPE[R625];
\end_layout

\begin_layout Plain Layout

unrelate self from type across R625;
\end_layout

\begin_layout Plain Layout

select one re related by self->RE[R514];
\end_layout

\begin_layout Plain Layout

unrelate self from re across R514;
\end_layout

\begin_layout Plain Layout

re.delete();
\end_layout

\begin_layout Plain Layout

delete object instance re;
\end_layout

\begin_layout Plain Layout

select many oprds related by self->OPRD[R631];
\end_layout

\begin_layout Plain Layout

for each oprd in oprds
\end_layout

\begin_layout Plain Layout

	oprd.delete();
\end_layout

\begin_layout Plain Layout

	delete object instance oprd;
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Data Usage:delete()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Empty Set
\end_layout

\begin_layout Standard
The empty set value is defined for all types, as all types define a set
 of values.
 e.g., 6 is a member of the set defined by the numeric type.
 The only legal operations performed on an empty set are population and
 comparison to the empty set.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R629
\end_layout

\begin_layout Subsection
Expression
\end_layout

\begin_layout Standard
An expression is a statement containing two operands and an operator.
\end_layout

\begin_layout Standard
Expression evaluation in the metamodel is done using Reverse Polish Notation
 (RPN).
 The order of construction involves adding the left-hand operand, the the
 right-hand operand, and then the operator.
 This allows the metamodel to evaluate the expression and produce an outcome.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

ordinal_position:integer Indicates the execution order of the expression
 within the equation.
\end_layout

\begin_layout Description
*id:unique_id
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
result_type_name:R632
\end_layout

\begin_layout Description
rh_operand_name:R617
\end_layout

\begin_layout Description
lh_operand_name:R616
\end_layout

\begin_layout Description
operator_type_name:R632
\end_layout

\begin_layout Description
operator_name:R632
\end_layout

\begin_layout Description
equation_id:R622
\end_layout

\begin_layout Subsection
Externally Specialized Value
\end_layout

\begin_layout Standard
The externally specialized value is the standard representation of a value
 that belongs to a set defined by commonly known types (e.g., the set of numerics).
 
\end_layout

\begin_layout Standard
As the actual value isn't that interesting to the metamodel, the attribute,
 value_name, is used to allow process model construction within the constraints
 the metamodel.
 This symbolic representation of the value is akin to the use of defines
 in C to represent "magic numbers".
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
value_name:string A symbolic representative for the value.
 In the case of a symbolic value type, it could be the actual value.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
type_name:R423
\end_layout

\begin_layout Description
*id:R629
\end_layout

\begin_layout Subsection
Keyword Instance
\end_layout

\begin_layout Standard
A keyword is a special directive to the architecture.
 Keywords are non-mathematical operands in equations in the process models.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

keyword:string The name of the action the keyword invokes.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
type_name:R423
\end_layout

\begin_layout Description
*id:R629
\end_layout

\begin_layout Subsection
Left Hand Operand
\end_layout

\begin_layout Standard
This is the operand on the left-hand side of the operator.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:R615
\end_layout

\begin_layout Subsection
Method Instantiation
\end_layout

\begin_layout Standard
A method instantiation occurs whenever a process model is using an accessor.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*object_id:R648
\end_layout

\begin_layout Description
*method_id:R648
\end_layout

\begin_layout Subsection
Operand
\end_layout

\begin_layout Standard
An Operand is a participant in an expression or sub-expression of an equation.
 All expressions are evaluated with only two operands, the one on the left-hand
 side of the operator and the one on the right-hand side of the operator.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*name:string A unique identifier for the type of operand.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*usage_id:R631
\end_layout

\begin_layout Subsubsection*
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one out related by self->OUT[R618];
\end_layout

\begin_layout Plain Layout

if (not empty out)
\end_layout

\begin_layout Plain Layout

	unrelate self from out across R618;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

select one lho related by self->LHO[R615];
\end_layout

\begin_layout Plain Layout

if (not empty lho)
\end_layout

\begin_layout Plain Layout

	unrelate self from lho across R615;
\end_layout

\begin_layout Plain Layout

	select one exp related by lho->EXP[R616];
\end_layout

\begin_layout Plain Layout

	unrelate lho from exp across R616;
\end_layout

\begin_layout Plain Layout

	delete object instance lho;
\end_layout

\begin_layout Plain Layout

	select one equ related by exp->EQU[R622];
\end_layout

\begin_layout Plain Layout

	equ.delete();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

select one rho related by self->RHO[R615];
\end_layout

\begin_layout Plain Layout

	if (not empty rho)
\end_layout

\begin_layout Plain Layout

		unrelate self from rho across R615;
\end_layout

\begin_layout Plain Layout

		select one exp related by rho->EXP[R617];
\end_layout

\begin_layout Plain Layout

		unrelate rho from exp across R617;
\end_layout

\begin_layout Plain Layout

		delete object instance rho;
\end_layout

\begin_layout Plain Layout

		select one equ related by exp->EQU[R622];
\end_layout

\begin_layout Plain Layout

		equ.delete();
\end_layout

\begin_layout Plain Layout

	end if;
\end_layout

\begin_layout Plain Layout

end if; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Operand:delete()
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Outcome
\end_layout

\begin_layout Standard
An outcome is the result of an expression or the result of a call to a synchrono
us accessor (function).
 
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
result_type_name:R634
\end_layout

\begin_layout Description
operand_name:R618
\end_layout

\begin_layout Description
type_name:R634
\end_layout

\begin_layout Description
operation_name:R634
\end_layout

\begin_layout Description
expression_id:R611
\end_layout

\begin_layout Description
**
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

equation_id:R622
\end_layout

\begin_layout Subsection
Parameter Instance
\end_layout

\begin_layout Standard
A parameter instance models the usage of a parameter in the process models.
 If the parameter is being assigned a value in the process model, then it
 is considered an activated parameter instance.
 If the parameter is being referenced in the process model, it is considered
 a placeholder parameter instance.
 A placeholder parameter instance will be uninitialized, so its associated
 value will be the empty set.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R626
\end_layout

\begin_layout Description
*parameter_name:R645
\end_layout

\begin_layout Description
*accessor_name:R645
\end_layout

\begin_layout Description
*type_name:R645
\end_layout

\begin_layout Description
*accessorInstance_id:R647
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one prm related by self->PRM[R645];
\end_layout

\begin_layout Plain Layout

unrelate self from prm across R645;
\end_layout

\begin_layout Plain Layout

select one ain related by self->AIN[R647];
\end_layout

\begin_layout Plain Layout

if (not empty ain)
\end_layout

\begin_layout Plain Layout

	unrelate self from ain across R647;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

select one var related by self->VAR[R626];
\end_layout

\begin_layout Plain Layout

unrelate self from var across R626;
\end_layout

\begin_layout Plain Layout

select one val related by var->VAL[R635];
\end_layout

\begin_layout Plain Layout

unrelate var from val across R635;
\end_layout

\begin_layout Plain Layout

select one dus related by var->DUS[R624];
\end_layout

\begin_layout Plain Layout

unrelate var from dus across R624;
\end_layout

\begin_layout Plain Layout

delete object instance var;
\end_layout

\begin_layout Plain Layout

dus.delete();
\end_layout

\begin_layout Plain Layout

delete object instance dus;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Parameter Instance:delete()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select any pro from instances of PRO where ( selected.action_id == param.actionId
 ) and ( selected.ordinal_position == param.ordinalPosition );
\end_layout

\begin_layout Plain Layout

create object instance ela of ELA;
\end_layout

\begin_layout Plain Layout

select one re related by self->VAR[R626]->DUS[R624]->RE[R514];
\end_layout

\begin_layout Plain Layout

relate re to pro across R502 using ela; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Parameter Instance:addToProcessModel()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Relationship Instance
\end_layout

\begin_layout Standard
A relationship instance is the instantiation of an instance relationship.
 Just as object instantiations need to be tracked and handled, so do relationshi
ps.
 This is limited to instance relationships, as associative relationships
 are handled as object instances.
\end_layout

\begin_layout Standard
The relationship represents a table containing a row for every instance
 of the relationship, and a column for each object participating in the
 relationship.
 When looking at the object model, a relationship represents the empty table.
 In the process model, the rows of the table are populated.
 The rows of the table, then represent relationship instance values.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
type_name:R421
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

left_id:R120
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

right_id:R120
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

relationship_number:R638
\end_layout

\begin_layout Description
*id:R629
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one rref related by self->RREF[R421];
\end_layout

\begin_layout Plain Layout

unrelate self from rref across R421;
\end_layout

\begin_layout Plain Layout

select one irl related by self->IRL[R638];
\end_layout

\begin_layout Plain Layout

unrelate self from irl across R638; select one rins related by self->INS[R120.'''
'];
\end_layout

\begin_layout Plain Layout

select one lins related by self->INS[R120.''is related to''];
\end_layout

\begin_layout Plain Layout

if (not empty rins and not empty lins)
\end_layout

\begin_layout Plain Layout

	unrelate lins from rins across R120.''is related to'' using self;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

select one val related by self->VAL[R629];
\end_layout

\begin_layout Plain Layout

unrelate self from val across R629;
\end_layout

\begin_layout Plain Layout

select one dus related by val->DUS[R624];
\end_layout

\begin_layout Plain Layout

unrelate val from dus across R624;
\end_layout

\begin_layout Plain Layout

delete object instance val;
\end_layout

\begin_layout Plain Layout

dus.delete();
\end_layout

\begin_layout Plain Layout

delete object instance dus;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Relationship Instance:delete()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Right Hand Operand
\end_layout

\begin_layout Standard
This is the operand on the right-hand side of the operator.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:R615
\end_layout

\begin_layout Subsection
Transient Data
\end_layout

\begin_layout Standard
Transient data is data that holds it's value only for the span of execution
 of a process model.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
name A string identifier for the data store that is unique for the process.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R626
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one var related by self->VAR[R626];
\end_layout

\begin_layout Plain Layout

select one val related by var->VAL[R635];
\end_layout

\begin_layout Plain Layout

unrelate var from val across R635;
\end_layout

\begin_layout Plain Layout

unrelate self from var across R626;
\end_layout

\begin_layout Plain Layout

select one dus related by var->DUS[R624];
\end_layout

\begin_layout Plain Layout

unrelate var from dus across R624;
\end_layout

\begin_layout Plain Layout

delete object instance var;
\end_layout

\begin_layout Plain Layout

dus.delete();
\end_layout

\begin_layout Plain Layout

delete object instance dus;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Transient Data:delete()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Value
\end_layout

\begin_layout Standard
Values are typed, read-only data, often held in variables.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R624
\end_layout

\begin_layout Subsection
Variable
\end_layout

\begin_layout Standard
Variables are typed, modifiable instances of data used to hold values for
 further processing.
\end_layout

\begin_layout Standard
A variable is a subset of a type set, whether the variable contains one
 value or many.
 When a variable is created without value assignment, it is an empty subset,
 and it can be thought of as uninitialized, containing no value, or null/none
 in common software language terms.
\end_layout

\begin_layout Standard
Variables are the only allowed targets of assignment operations.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
value_id:R635
\end_layout

\begin_layout Description
*id:R624
\end_layout

\begin_layout Section
Relationship Descriptions
\end_layout

\begin_layout Description
R611 An expression results in an outcome.
 The outcome is the result of an expression.
\end_layout

\begin_layout Description
R615 An operand will be considered the left-hand or right-hand operand participa
ting in the expression.
\end_layout

\begin_layout Description
R616 An expression can use a left-hand operand, and a left-hand operand
 is always used in an expression.
 The boolean operator, not, is an example of an expression without a left
 hand operand.
\end_layout

\begin_layout Description
R617 An expression uses a right-hand operand, and a right-hand operand is
 used in an expression.
\end_layout

\begin_layout Description
R618 An outcome results in an operand.
 This is always true, because assignment is an operator, and there is no
 reason to have an expression without an assignment.
 An operand isn't always the result of an outcome.
\begin_inset Newline newline
\end_inset


\begin_inset Newline newline
\end_inset

Note: in complex equations, there are multiple outcomes and the production
 of temporary operands.
 e.g., x = (a + 5) * (a - 2), and a = 3: LHO1 = x; LHO2 = a; LHO3 = a; TYOP1
 = '+'; RHO1 = 5; RHO2 = 2; TYOP2 = '+'.
 LHO1 = x; OUT1 = 8; LHO4 = 8; OUT2 = 1; RHO3 = 1.
 TYOP3 = '*'; LHO1 = x; OUT3 = 8; RHO4 = 8.
 TYOP4 = '='.
 OUT4 = 8; LHO5 = 8.
\end_layout

\begin_layout Description
R622 An equation includes one or more expressions.
 The expressions compose the equation.
 Equation evaluation in the metamodel is done using Reverse Polish Notation
 (RPN).
 The order of construction involves evaluating the left-most expression,
 then evaluating the right-most expression, and then the operator.
 The metamodel uses the ordinal position of the expression to decide evaluation
 order.
\end_layout

\begin_layout Description
R624 Data usage is either as a variable or a value.
\end_layout

\begin_layout Description
R625 Data usage is constrained by one type, and a type can constrain multiple
 data usages.
\end_layout

\begin_layout Description
R626 The variable data is transient data used by Process Models, attributes
 of object instances, or parameters of accessor instances.
\end_layout

\begin_layout Description
R629 The specialization of all values used in Shlaer-Mellor modeling.
\end_layout

\begin_layout Description
R631 An operand represents one data usage, and data usage can be represented
 by many operands.
 Even though an equation can be further broken down in a way that's not
 visible to the analyst, the break down represents atomic pieces of data
 usage, so while there are many data usages through the break downs in an
 operand, each individual break down is what is modeled by this relationship.
 
\begin_inset Newline newline
\end_inset

e.g., x = func(z) + (y * z) breaks down to: * value of y times the value of
 z is assigned to invisible transient variable r.
 * value of z is assigned to parameter of func(), p.
 * return value of func(p) is assigned to invisible transient variable q.
 * value of q plus the value of r is assigned to x.
 10 data usages(6 values + 4 variables), 10 operands
\end_layout

\begin_layout Description
R632 An expression uses a typed operator, but a typed operator can be used
 in many expressions, even in the same equation.
\end_layout

\begin_layout Description
R634 The outcome of an expression is typed by the typed operator's result
 type.
\end_layout

\begin_layout Description
R635 Values can be assigned to one or more variables at any given time,
 and a variable always has an assigned value.
 If no explicit assignment has been made, then the variable holds the default
 value for the data type.
 Values exist without variables.
 Consider the set of numeric values.
 It would be wrong to suggest the numeral one or the decimal one-half don't
 exist in the absence of a variable.
 Variables in action language aren't created or typed without assignment
 (explicit or implicit), so there's no reason to assume an untyped (no default)
 variable would exist per this metamodel.
\end_layout

\begin_layout Description
R636 An unspecialized value always belongs to the set defined by a type.
 A type provides the definition for all of it's values.
 This relationship requires creation of a value for every type.
 While this seems onerous, the relationship between value and variable implies
 that a default value exists for every type, therefore the values required
 by this relationship compose the set of default values.
\end_layout

\begin_layout Description
R638 A relationship instance instantiates one instance relationship, and
 an instance relationship can be instantiated by many relationship instances.
\end_layout

\begin_layout Description
R640 A accessor instance instantiates one accessor, and an accessor can
 be instantiated by many accessor instances.
\end_layout

\begin_layout Description
R642 A non-referential attribute can be instantiated as one or more attribute
 instances, and an attribute instance is always the instantiation of a non-refer
ential attribute.
 Referential attributes are always instantiated as the referred to non-referenti
al attributes.
\end_layout

\begin_layout Description
R643 An object instance owns one or more attribute instances, and an attribute
 instance always belongs to one object instance.
 
\end_layout

\begin_layout Description
R645 A parameter can be instantiated as one or more parameter instances,
 and a parameter instance is always an instantiation of one parameter.
\end_layout

\begin_layout Description
R647 A parameter instance belongs to an accessor instance, and an accessor
 instance can have many parameter instances.
\end_layout

\begin_layout Description
R648 An accessor instance only belongs to an object instance during a method
 instantiation, and an object instance can have a method instantiation for
 one or more accessor instances.
\begin_inset Newpage newpage
\end_inset


\end_layout

\begin_layout Chapter
The Domain Subsystem
\end_layout

\begin_layout Standard
The subsystem of the metamodel concerning domain objects.
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Domain-Package Diagram.png
	width 70page%

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Domain Subsystem Diagram
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Section
Object and Attribute Descriptions
\end_layout

\begin_layout Subsection
Asynchronous Bridge
\end_layout

\begin_layout Standard
An asynchronous bridge returns no data and only invokes action in the servicing
 domain.
\end_layout

\begin_layout Standard
Special considerations: A Transfer Vector provides an external domain with
 the information needed to invoke an event on an instance within the domain
 being modeled.
 This means that the transfer vector must include the instance reference
 and event reference.
 It is up to the Architecture to determine how this information is handled,
 but the external domain should treat the transfer vector information as
 a composite.
 i.e., the external domain will not be able to access the instance or event
 references directly.
\end_layout

\begin_layout Standard
"The analyst can think of the transfer vector as a partial event (an event
 label and an instance identifier only) that will be filled out with supplementa
l data (if such is defined for the base event) and returned to Home as a
 complete event at some future time.
 ...
\end_layout

\begin_layout Standard
When Away receives a transfer vector from Home, Away regards the transfer
 vector as a data element of type 'transfer vector.' Away must save the transfer
 vector for later use.
 This is done by attributing the transfer vector to an object that acts
 as a surrogate for the thread of control in the sending domain.
 ...
\end_layout

\begin_layout Standard
When it is time for Away to provide the asynchronous notification to Home,
 Away invokes an asynchronous return wormhole, supplying as input data:
 • the previously saved transfer vector • any additional data elements to
 be returned to the calling domain (Home).
 These will be combined with the transfer vector as supplemental data items
 to form the event expected by Home.
 The asynchronous return wormhole acts as a way to "return via transfer
 vector" back to the Home domain."
\begin_inset CommandInset citation
LatexCommand cite
key "Worm"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

name:R506
\end_layout

\begin_layout Description
*id:R3
\end_layout

\begin_layout Subsection
Bridge
\end_layout

\begin_layout Standard
"During analysis, a bridge between two domains represents a set of assumptions
 (from the client's perspective) and a set of requirements (from the server's).
\end_layout

\begin_layout Itemize
The client thinks of a bridge as a set of capabilities that it assumes will
 be provided by another domain.
 The client does not care which domain provides the capabilities.
\end_layout

\begin_layout Itemize
The server thinks of the bridge as a set of requirements.
 The server does not care which domain needs the service, and therefore
 makes no assumptions about the client."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
Bridges can contain both synchronous and asynchronous processes.
 The following is a list of assumptions, on bridging domains, taken from
 
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset

:
\end_layout

\begin_layout Itemize
OOA Mechanisms: "The application and service domains assume that the mechanisms
 of OOA (data storage, event transmission, and the like) are provided in
 some form." This means the other domains have a way of persisting shared
 data, handling events directed at them, synchronizing time, etc.
 This is the same as client and server computing machines.
\end_layout

\begin_layout Itemize
Instant Data Attributes: "The application domain assumes that sensor-based
 attributes such as Cooking Tank.Actual Temperature have up-to-date values."
 The action of such a bridge will be considered part of the atomicity in
 the process model that calls it.
 Access will work as if it is from a data store.
\end_layout

\begin_layout Itemize
Counterparts: "Although an object in one domain doesn't require the existence
 of an object in another, an instance of object in one domain may have as
 a counterpart an instance of an object in another domain.
 For example, a train (in the Railroad Management domain) may have a counterpoin
t train icon in the User Interface domain."
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*bridge_id:R509
\end_layout

\begin_layout Subsection
Domain
\end_layout

\begin_layout Standard
"A domain is a separate real, hypothetical, or abstract world inhabited
 by a distinct set of objects that behave according to the rules and policies
 characteristic of the domain."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*name:string The descriptive identifier for the domain.
\end_layout

\begin_layout Subsection
External Domain
\end_layout

\begin_layout Standard
An external domain is a domain that requires or provides services to the
 domain being modeled.
 An external domain can be another Shlaer-Mellor modeled domain or a realized
 domain.
\end_layout

\begin_layout Standard
The realized domain can be modeled using some other modeling method, might
 be existing code, or might be an executable.
 The bridges from a modeled domain to a realized domain are defined in the
 model with respect to the modeled domain's requirements, and they can require
 some extra integration logic, external to the model, to meet the needs
 of the realized domain.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:R1
\end_layout

\begin_layout Subsection
Incoming Bridge
\end_layout

\begin_layout Standard
An incoming bridge represents a service provided by the domain being modeled.
 A synchronous, incoming bridge returns data to the external domain in a
 timely fashion.
 An asynchronous, incoming bridge doesn't return data the the external domain.
\end_layout

\begin_layout Standard
An incoming bridge might also be referred to as a "domain function".
\end_layout

\begin_layout Standard
Although incoming bridges are intended for external access, they can also
 be called internally by the domain being modeled.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R4
\end_layout

\begin_layout Description
domain_name:R6
\end_layout

\begin_layout Subsection
Modeled Domain
\end_layout

\begin_layout Standard
A modeled domain is a domain that has been modeled in accordance with the
 rules of the Shlaer-Mellor metamodel.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:R1
\end_layout

\begin_layout Subsection
Outgoing Bridge
\end_layout

\begin_layout Standard
An outgoing bridge is the requirement the domain being modeled places on
 an external domain for services.
 A synchronous, outgoing bridge is expected to return data from the external
 domain.
 An asynchronous, outgoing bridge is expected to invoke some action in the
 external domain.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R4
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

ee_name:R5
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

domain_name:R5
\end_layout

\begin_layout Subsection
Synchronous Bridge
\end_layout

\begin_layout Standard
A synchronous bridge always returns data to the caller in a timely fashion.
 Timely should be defined by the domain providing the service.
 
\end_layout

\begin_layout Standard
A synchronous bridge provided by another domain can launch asynchronous
 actions to obtain the return value, but this domain will be blocked while
 waiting on the actions to complete.
 The analyst should take this into consideration.
 If the external domain definition of timely doesn't match the modeled domain
 definition of timely, then some mechanism must be put in place to allow
 the bridge to be treated as an asynchronous bridge.
\end_layout

\begin_layout Standard
Special considerations: A synchronous service is used to access a data value
 from an external domain.
\end_layout

\begin_layout Standard
NOTE: It is legal for the domain being modeled to call its own synchronous
 service as well.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

name:R524
\end_layout

\begin_layout Description
*id:R3
\end_layout

\begin_layout Section
Relationship Descriptions
\end_layout

\begin_layout Description
R1 A domain is either a modeled domain or a realized domain.
\end_layout

\begin_layout Description
R3 A bridge is expected to synchronously return data, or asynchronously
 invoke action.
\end_layout

\begin_layout Description
R4 A bridge is either incoming (handled internally) or outgoing (handled
 externally).
\end_layout

\begin_layout Description
R5 In the context of the domain being modeled, the modeled domain might
 require services from external domains.
 An external domain specified in the model will provide services to only
 the modeled domain.
\begin_inset Newline newline
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset

In reality, the external domain would provide services to other domains,
 modeled and non-modeled, but in the context of the domain being modeled,
 it is the only domain requiring services.
 
\begin_inset Newline newline
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset

Even though a 1:M relationship doesn't require an associative object, making
 the outgoing bridge an associative object constrains outgoing bridges to
 be explicitly associated with the client-server relationship between two
 domains.
\end_layout

\begin_layout Description
R6 An incoming bridge models the services provided by the modeled domain.
\end_layout

\begin_layout Chapter
The Dynamics Subsystem
\end_layout

\begin_layout Standard
The subsystem of the metamodel concerned with object and relationship dynamics.
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Dynamics-Package Diagram.png
	width 70page%

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Dynamics Subsystem Diagram
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Section
Object and Attribute Descriptions
\end_layout

\begin_layout Subsection
Assigner
\end_layout

\begin_layout Standard
The Assigner is a "state model that is responsible for creating instances
 of the relationship by associating instances of the participating objects
 with one another.
 ...
 the purpose of the Assigner is to act as a single point of control through
 which competing requests are serialized".
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
An Assigner is object-based, not instance-based.
 This means that state is maintained for the object, not for each instance
 of the object.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*subset_name:R354
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

reference_id:R514
\end_layout

\begin_layout Description
starter_id:R345
\end_layout

\begin_layout Description
starter_name:R345
\end_layout

\begin_layout Description
*id:R300
\end_layout

\begin_layout Subsection
Assigner Machine
\end_layout

\begin_layout Standard
An assigner machine is the runtime instantiation of an assigner model.
 The assigner machine exists for the life of the system, so it is not dynamicall
y created or destroyed.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
name:R352
\end_layout

\begin_layout Description
assigner_id:R352
\end_layout

\begin_layout Description
*id:R350
\end_layout

\begin_layout Subsection
Assignment
\end_layout

\begin_layout Standard
An assignment is the result of an assigner state model creating a relationship
 between two object instances.
 The assignment represents the associative relationship instantiation and
 the associative object instantiation.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*relationship_id:R302
\end_layout

\begin_layout Description
*machine_id:R351
\end_layout

\begin_layout Subsection
Cannot Happen
\end_layout

\begin_layout Standard
"The "can't happen" entry is reserved for occasions when the event simply
 cannot happen in the real world.
 For example, the event V3: Door opened cannot happen when the oven is in
 state 5, since in that state the door is already opened."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R331
\end_layout

\begin_layout Subsection
Creation State
\end_layout

\begin_layout Standard
A creation state is a start state that might not be depicted on a state
 model.
 The Shlaer-Mellor notation showed an arrow coming from nothing and entering
 a state.
 In that case, the nothing is the creation state.
 A creation state will never have a transition entering it.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R313
\end_layout

\begin_layout Description
*name:R313
\end_layout

\begin_layout Subsection
Deletion State
\end_layout

\begin_layout Standard
A deletion state, upon exit, causes the lifecycle state machine and associated
 object instance to cease to exist.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R305
\end_layout

\begin_layout Description
*state_name:R305
\end_layout

\begin_layout Subsection
Destructor
\end_layout

\begin_layout Standard
The destructor is responsible for removing all segments upon completion
 of the state machine processing.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
delete_name:R349
\end_layout

\begin_layout Description
delete_id:R349
\end_layout

\begin_layout Description
machine_id:R349
\end_layout

\begin_layout Subsection
Entry Data
\end_layout

\begin_layout Standard
An entry data is a member of the set of data defined for an entry rule.
 Any event transitioning into the entry rule must carry the exact same amount
 and type of parameter data as the entry data.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id A unique identifier for the entry data.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*model_id:R357
\end_layout

\begin_layout Description
*state_name:R357
\end_layout

\begin_layout Description
type_name:R359
\end_layout

\begin_layout Description
rule_id:R357
\end_layout

\begin_layout Subsection
Entry Rule
\end_layout

\begin_layout Standard
The entry transition rule enforces the "same data rule", which states, "All
 events that cause a transition into a particular state must carry exactly
 the same event data."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
OL:MWS
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset

 and OOA96
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset

 define the data as, identifier data and supplemental data, where the supplement
al data is the external data supplied as event parameters, and the identifier
 data is the target state designator.
\end_layout

\begin_layout Standard
This means that an entry rule is composed of the parameter data to be carried
 by the event causing the transition, and the destination state designator.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*model_id:R325
\end_layout

\begin_layout Description
*state_name:R325
\end_layout

\begin_layout Description
*id:R321
\end_layout

\begin_layout Subsection
Event Ignored
\end_layout

\begin_layout Standard
"If an object refuses to respond to a particular event when it is in a certain
 state, enter "event ignored" in the appropriate cell.
 When an event is ignored, the instance stays in the same state it is in
 and does not re-execute the action.
 ...
 Note that although the event is ignored in the sense of not causing a transitio
n, the event is used up by the state model."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R331
\end_layout

\begin_layout Subsection
Exit Rule
\end_layout

\begin_layout Standard
An exit transition rule defines what happens when an event occurs while
 in the current state.
 This means that an exit rule is defined for every event defined for the
 state model.
 The exit rule requires the event designator and the transition result,
 which is a destination state or a transition failure designator.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
name:R326
\end_layout

\begin_layout Description
state_id:R324
\end_layout

\begin_layout Description
state_name:R324
\end_layout

\begin_layout Description
event_name:R326
\end_layout

\begin_layout Description
*id:R321
\end_layout

\begin_layout Subsection
General Segment
\end_layout

\begin_layout Standard
A general segment is included in all instantiations of an object specialization
 branch.
 It can be the whole lifecycle model for an object instance.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R363
\end_layout

\begin_layout Subsection
Lifecycle Model
\end_layout

\begin_layout Standard
A lifecycle state model abstracts the common behavior of an object that
 applies to all instances.
 "Two forms of state models are commonly used in analysis; in OOA, we use
 the Moore form."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset

 
\end_layout

\begin_layout Standard
Although there is no direct relationship between instance and lifecycle,
 the relationship is explicitly directed by the mandatory relationship between
 lifecycle and object and the mandatory relationship between instance and
 object.
 The empty set makes this very ugly to model explicitly, because the relationshi
p between Instance and Lifecycle has to be 1c:Mc and be dependent on the
 already modeled path from Instance to Object to Lifecycle.
 The logical associative object would be "Active Instance", which would
 imply a "Passive Instance" object be created as part of a subtyping of
 Instance.
\end_layout

\begin_layout Standard
A Lifecycle is instance-based, not object-based.
 This means that state is maintained for each instance of the object, not
 for the object, but the model of behavior is defined the same for all instances
 of the object.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*subset_name:R347
\end_layout

\begin_layout Description
*id:R300
\end_layout

\begin_layout Subsection
Lifecycle State Machine
\end_layout

\begin_layout Standard
A lifecycle state machine is the runtime instantiation of a lifecycle state
 model.
 The lifecycle state machine can be composed of many state model segments,
 when the instantiation involves multiple subsets with lifecycle state models,
 or is composed from one segment when instantiating only one subset with
 a state model.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
instance_id:R361
\end_layout

\begin_layout Description
model_name:R360
\end_layout

\begin_layout Description
model_id:R360
\end_layout

\begin_layout Description
start_id:R348
\end_layout

\begin_layout Description
start_name:R348
\end_layout

\begin_layout Description
*id:R350
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one smc related by self->SMC[R350];
\end_layout

\begin_layout Plain Layout

select one sta related by smc->STA[R353];
\end_layout

\begin_layout Plain Layout

unrelate smc from sta across R353;
\end_layout

\begin_layout Plain Layout

unrelate smc from self across R350;
\end_layout

\begin_layout Plain Layout

delete object instance smc;
\end_layout

\begin_layout Plain Layout

select one lif related by self->LIF[R360];
\end_layout

\begin_layout Plain Layout

unrelate self from lif across R360;
\end_layout

\begin_layout Plain Layout

select one cre related by self->CRE[R348];
\end_layout

\begin_layout Plain Layout

unrelate self from cre across R348;
\end_layout

\begin_layout Plain Layout

select one del related by self->DEL[R349];
\end_layout

\begin_layout Plain Layout

if (not empty del)
\end_layout

\begin_layout Plain Layout

	select one des related by self->DES[R349];
\end_layout

\begin_layout Plain Layout

	unrelate self from del across R349 using des;
\end_layout

\begin_layout Plain Layout

	delete object instance des;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

select one ins related by self->INS[R361];
\end_layout

\begin_layout Plain Layout

unrelate self from ins across R361;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Lifecycle State Machine:delete()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Living State
\end_layout

\begin_layout Standard
A living state is any state of the object in an assigner state model, or
 if in a lifecycle state model, any state that doesn't automatically delete
 the associated instance at the end of state action processing.
 All living states should have outgoing and incoming transitions.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R305
\end_layout

\begin_layout Description
*name:R305
\end_layout

\begin_layout Subsection
Middle State
\end_layout

\begin_layout Standard
The middle state is a state that isn't a start or deletion state.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R306
\end_layout

\begin_layout Description
*name:R306
\end_layout

\begin_layout Subsection
Non-Creation State
\end_layout

\begin_layout Standard
A non-creation state is a start state that has been designated as the starting
 state for the existance of the state model.
 A non-creation state can contain a process model and be a destination for
 state-to-state transition.
 The instance must be created outside of the state model.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R313
\end_layout

\begin_layout Description
*name:R313
\end_layout

\begin_layout Subsection
Peer Segment
\end_layout

\begin_layout Standard
A peer segment is a specializing segment that specializes two lifecycles.
 It is instantiated when two overlapping sets share a common behavior for
 a portion of their lifecycle.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*segment_id:R364
\end_layout

\begin_layout Subsection
Splice Segment
\end_layout

\begin_layout Standard
A splice segment is a specializing segment that belongs to a single lifecycle.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*segment_id:R364
\end_layout

\begin_layout Subsection
Splicing
\end_layout

\begin_layout Standard
A splicing represents the association between a state model segment and
 the lifecycle model.
 When you have a single splicing instance, you don't really have a splicing
 as defined in OL:MWS
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset

, but the concept that a set is a subset allows this to be modeled as all
 lifecycle models are splicings.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*model_name:R362
\end_layout

\begin_layout Description
*model_id:R362
\end_layout

\begin_layout Description
*segment_id:R362
\end_layout

\begin_layout Subsection
Start State
\end_layout

\begin_layout Standard
A start state is any living state that has been designated to be the state
 of existence upon object realization or instance creation in the system.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R306
\end_layout

\begin_layout Description
*name:R306
\end_layout

\begin_layout Subsection
State
\end_layout

\begin_layout Standard
"A state represents a condition of the object in which a defined set of
 rules, policies, regulations, and physical laws applies."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

number:integer A number for the state, that can uniquely identify it within
 its state model.
\end_layout

\begin_layout Description
*name:string A symbolic value describing the state, that can uniquely identify
 it within its state model.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
3
\end_layout

\end_inset

activity_id:R509
\end_layout

\begin_layout Description
**
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

model_id:R341
\end_layout

\begin_layout Subsection
State Machine
\end_layout

\begin_layout Standard
A state machine is the runtime instantiation of a state model.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id A unique identifier for the state machine.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_id:R353
\end_layout

\begin_layout Description
current_name:R353
\end_layout

\begin_layout Subsection
State Model
\end_layout

\begin_layout Standard
A state model formalizes the dynamic behavior of an object or of subsets
 of an object.
 The state models are either instance based, called lifecycle models, or
 assigners, which exist regardless of instantiation.
\end_layout

\begin_layout Standard
For lifecycles, Shlaer-Mellor allows the concept of a split state model.
 In a split state model, a segment of the state model is modeled in an object
 specialization.
 The whole lifecycle depends upon which specializations compose the instantiatio
n.
 This allows object specialization on behavior.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id A unique identifier for the state model.
\end_layout

\begin_layout Subsection
State Model Segment
\end_layout

\begin_layout Standard
A state model segment is any portion of the state model that exists only
 in one subset of the object.
 Since the subset can be a set, a state model segment in the general case
 is the whole state model.
 In the case where the subset doesn't represent the whole set, the state
 model segment is a behavior specialization of the object.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id A unique identifier for the state model segment.
\end_layout

\begin_layout Subsection
Successful Transition
\end_layout

\begin_layout Standard
In a successful state-to-state transition, the result of the event was a
 state entry.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
state_id:R332
\end_layout

\begin_layout Description
state_name:R332
\end_layout

\begin_layout Description
*id:R355
\end_layout

\begin_layout Subsection
Transition
\end_layout

\begin_layout Standard
A transition represents a change in state within the same object state model.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id A unique identifier for the transition.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
model_id:R323
\end_layout

\begin_layout Description
state_name:R323
\end_layout

\begin_layout Description
exit_id:R329
\end_layout

\begin_layout Description
entry_id:R323
\end_layout

\begin_layout Subsection
Transition Rule
\end_layout

\begin_layout Standard
A transition rule defines the signature required for entry into or exit
 from a state.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id A unique identifier for the transition rule.
\end_layout

\begin_layout Subsection
Unsuccessful Transition
\end_layout

\begin_layout Standard
An unsuccessful transition does not change the state of an instance, and
 can be used to trigger error handling mechanisms as directed by the architectur
e.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:R355
\end_layout

\begin_layout Section
Relationship Descriptions
\end_layout

\begin_layout Description
R300 There are two types of state models in Shlaer-Mellor, Lifecycle of
 an instance and Assigner for relationships involving competition.
\end_layout

\begin_layout Description
R302 An assignment instantiates an associative relationship and an instance
 of the associative object.
 As not all associative relationships involve contention, not every one
 is the result of an assignment.
\end_layout

\begin_layout Description
R305 A state in the state model is either a living state, or in the case
 of a lifecycle model is a deletion state to remove the object instance
 upon completion of the state action.
\end_layout

\begin_layout Description
R306 A living state can be designated as a creation state.
 A state model will only have one creation state.
\begin_inset Newline newline
\end_inset

The creation aspect could be made an attribute of living state, but that
 would imply that the creation aspect wasn't permanent.
 There should be no reason to dynamically change which state is designated
 for creation.
 
\end_layout

\begin_layout Description
R313 A start state is either a creation state, or a non-creation, entry
 state.
\end_layout

\begin_layout Description
R321 A transition rule defines either the rules for entry into or exit from
 a state.
\end_layout

\begin_layout Description
R323 Every transition requires that an entry rule is defined for the destination
 state.
 An entry rule applies to all transitions into the state.
\end_layout

\begin_layout Description
R324 A living state requires one or more exit rules to specify the conditions
 required to exit the state.
\end_layout

\begin_layout Description
R325 An entry rule specifies the entry conditions required to be met before
 entry into the target state.
\begin_inset Newline newline
\end_inset

Non-creation, start states might only have exit transitions, so the requirement
 to have an entry rule is conditional.
\end_layout

\begin_layout Description
R326 The exit rule must contain a reference to the event that causes exit
 from the current state.
 An event is always referenced by an exit rule.
\end_layout

\begin_layout Description
R329 Every transition requires an exit rule, so an exit rule is defined
 for each transition.
\end_layout

\begin_layout Description
R331 An unsuccessful transition is constrained by the rules of Shlaer-Mellor
 to be an "event ignored" or "can't happen" result.
\end_layout

\begin_layout Description
R332 A successful transition always enters a state.
 A state can be specified as the destination for more than one transition.
 Only a start state might not be a destination for a successful transition.
\end_layout

\begin_layout Description
R341 A state model contains states.
 The states are specified by the state model.
\end_layout

\begin_layout Description
R345 An assigner is started in the designated starting state on application
 start.
\end_layout

\begin_layout Description
R347 A subset, which can be a whole set, can have its dynamics modeled in
 a lifecycle state model.
 A lifecycle state model will always model the dynamics of one subset.
\end_layout

\begin_layout Description
R348 All state machines start in a start state designated for the state
 model.
 There is only one start state for a state machine, but it is assigned for
 all the state machine instances.
\end_layout

\begin_layout Description
R349 A deletion state finalizes a state machine.
 The deletion state process will destroy all the associated state machine
 instances.
\end_layout

\begin_layout Description
R350 A state machine is either a lifecycle machine or an assigner machine.
\end_layout

\begin_layout Description
R351 Assignments are created and managed by the assigner state machine.
\end_layout

\begin_layout Description
R352 The assigner state model constrains the operation of the assigner state
 machine.
 The assigner state machine must conform to the assigner state model.
\begin_inset Newline newline
\end_inset

Unlike for lifecycle models and machines, the relationship is unconditional
 on both ends, because the assigner machine isn't tied to an instantiation
 of an object.
\end_layout

\begin_layout Description
R353 A state machine is currently spending time in a state, and a state
 is a defined point of time for a state machine.
\end_layout

\begin_layout Description
R354 An assigner manages contention for a subset, and a subset has contention
 managed by an assigner.
\end_layout

\begin_layout Description
R355 A transition is a successful transition or an unsuccessful transition.
 Modeling both of these allows the state transition table to be fully specified.
\end_layout

\begin_layout Description
R356 An event is always constrained by one entry rule, and an entry rule
 constrains all the events that are directed to the same state.
\end_layout

\begin_layout Description
R357 An entry rule is composed of its entry data, even in the no entry data
 case.
 Entry data is used to compose a single entry rule.
\end_layout

\begin_layout Description
R358 A single entry data is associated with one or more event parameters,
 but an event parameter conforms to only one entry data.
\end_layout

\begin_layout Description
R359 Entry data is constrained by a type, and a type can constrain entry
 data.
\end_layout

\begin_layout Description
R360 A lifecycle model is instantiated as a lifecycle state machine, and
 a lifecycle state machine instantiates a lifecycle model.
\end_layout

\begin_layout Description
R361 A lifecycle state machine controls the life of one object instance,
 and an object instance can be controlled by a lifecycle state machine.
\begin_inset Newline newline
\end_inset

Every instance has it's own state machine.
\end_layout

\begin_layout Description
R362 A lifecycle model is composed of one or more state model segments,
 and a state model is a path in one or more lifecycles.
 The multiplicity of the latter is driven by the possibility of a set intersecti
on.
\end_layout

\begin_layout Description
R363 A state model segment is a general segment in the case where it represents
 the whole state model, and a state model segment is a specializing segment
 in the case where it represents only a portion of the state model.
\end_layout

\begin_layout Description
R364 A specializing segment can belong to more than one lifecycle when there
 are intersecting sets with common behavior; this type of segment is a peer
 segment.
 When the specializing segment belongs to only one lifecycle, it is a splice
 segment.
\end_layout

\begin_layout Chapter
The Object Subsystem
\end_layout

\begin_layout Standard
The subsystem of the metamodel concerning objects, instances, and attributes.
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Object-Package Diagram.png
	width 70page%

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Object Subsystem Diagram
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Section
Object and Attribute Descriptions
\end_layout

\begin_layout Subsection
Attribute
\end_layout

\begin_layout Standard
An attribute is used to characterize aspects of the objects within a domain.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*name:string A descriptive string concerning the characterization.
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

belongsTo = true;
\end_layout

\begin_layout Plain Layout

select one oa related by self->OA[R124] where selected.object_name == param.object
;
\end_layout

\begin_layout Plain Layout

if (empty oa)
\end_layout

\begin_layout Plain Layout

	select one spa related by self->SPA[R124] where selected.subtype_name ==
 param.object;
\end_layout

\begin_layout Plain Layout

	if (empty spa)
\end_layout

\begin_layout Plain Layout

		belongsTo = false;
\end_layout

\begin_layout Plain Layout

	end if;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

return belongsTo;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
boolean Attribute:belongsTo()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Chording
\end_layout

\begin_layout Standard
A chording represents all the chords belonging to a supertype partitioning.
\end_layout

\begin_layout Standard
Proper subsets are never partitioned by a chord, so the supertype partitioning
 of a subset requires a separate relationship in the metamodel.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*object_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*domain_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*supertype_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Derivation
\end_layout

\begin_layout Standard
A derivation is a dependency mapping between two attributes.
 The attributes can be from the same object or different objects.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*derived_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*value_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
attribute_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Identification Participation
\end_layout

\begin_layout Standard
Formalizes all attribute participation in identification of an object's
 instances.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
groupId:integer A number used to identify a group of identifiers.
 Each group of identifiers are used to uniquely identify an object instance.
\begin_inset Newline newline
\end_inset

The preferred identifier will have a groupId value of 1.
 The preferred identifier is the only identifier used to formalize an instance
 relationship as referential attributes.
\begin_inset Newline newline
\end_inset

"An object may have several identifiers, each composed of one or more attributes.
 For example, an Airport object may have the attributes
\begin_inset Newline newline
\end_inset

 
\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset

Airport Code
\begin_inset Newline newline
\end_inset

 
\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset

Latitude
\begin_inset Newline newline
\end_inset

 
\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset

Longitude
\begin_inset Newline newline
\end_inset

 
\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset

City
\begin_inset Newline newline
\end_inset

 
\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset


\begin_inset space ~
\end_inset

Number of Passenger Gates
\begin_inset Newline newline
\end_inset

The Airport Code attribute is an identifier of the Airport object, and the
 combination of Latitude and Longitude is another identifier of Airport.
\begin_inset Newline newline
\end_inset

If an object has multiple identifiers, one such identifier is chosen as
 the preferred identifier."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\begin_inset Newline newline
\end_inset

In tools, like BridgePoint, an indication is placed next to identifying
 attributes, and grouping of identifiers is done numerically.
 e.g., {I}, {I2}, {I3}, etc.
 This metamodel is just using a numeric indicator.
 The numeral, 1, is the preferred identifier, and like BridgePoint, the
 editor part of the toolset might choose to only display numerals greater
 than one.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute> The name of the attribute used for identification.
\end_layout

\begin_layout Description
*id:same_as<Base_Attribute> The unique identifier for the Identifier instance.
\end_layout

\begin_layout Subsection
Identifier
\end_layout

\begin_layout Standard
An identifier is used to uniquely identify the members of a set.
 "An identifier is a set of one or more attributes whose values uniquely
 distinguish each instance of an object."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
The set always has one identifying attribute that applies to all set members,
 but some identifying might only apply to some subset members.
 e.g., a subset formed from the intersection of two sets will have at least
 two identifying attributes, one from each set.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id A unique identifier for the instance identifier in the domain.
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select many idps related by self->IDP[R102];
\end_layout

\begin_layout Plain Layout

for each idp in idps
\end_layout

\begin_layout Plain Layout

	select one atr related by idp->ATR[R102];
\end_layout

\begin_layout Plain Layout

	unrelate self from atr across R102 using idp;
\end_layout

\begin_layout Plain Layout

	delete object instance idp;
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\begin_layout Plain Layout

select many itns related by self->ITN[R101];
\end_layout

\begin_layout Plain Layout

for each itn in itns
\end_layout

\begin_layout Plain Layout

	select one ins related by itn->INS[R101];
\end_layout

\begin_layout Plain Layout

	unrelate self from ins across R101 using itn;
\end_layout

\begin_layout Plain Layout

	delete object instance itn;
\end_layout

\begin_layout Plain Layout

	ins.delete();
\end_layout

\begin_layout Plain Layout

	delete object instance ins;
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Identifier:delete()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Instance Identification
\end_layout

\begin_layout Standard
An instantiation is the creation of an identifier for an instance that is
 a member of a subset.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*instance_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*id_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Intersecting
\end_layout

\begin_layout Standard
An intersecting proper subset is formed from the intersection of two or
 more sets.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Intersection
\end_layout

\begin_layout Standard
The intersection associative object is used to track the participants in
 the intersecting proper subset formation brought about by multiple objects.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*object_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*domain_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*subtype_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

specialization_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Multi-level Partitioning
\end_layout

\begin_layout Standard
Multi-level partitioning abstracts the relationship formed when a proper
 subset is further partitioned (subset) by a supertype partitioning.
\end_layout

\begin_layout Standard
A multi-level partitioning is instantiated whenever a subtype is subtyped
 in the object model.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*supertype_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*supertype_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Non-Intersecting
\end_layout

\begin_layout Standard
A non-intersecting proper subset is a subset of only one set.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
supertype_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Non-referential Attribute
\end_layout

\begin_layout Standard
A non-referential attribute "is an abstraction of a single characteristic
 possessed by all entities that were themselves abstracted as an object."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
It should be noted that at least one of the non-referential attributes related
 to an object will participate in identification of the instances.
 While precedence has been set in some tools to not abstract arbitrary identifie
rs, a primary key must exist, and it would be specious to say we can assume
 it's existence.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
type_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select any ins from instances of INS where selected.id == param.objectInstance;
\end_layout

\begin_layout Plain Layout

create object instance atn of ATN;
\end_layout

\begin_layout Plain Layout

relate atn to self across R642;
\end_layout

\begin_layout Plain Layout

relate atn to ins across R643;
\end_layout

\begin_layout Plain Layout

create object instance var of VAR;
\end_layout

\begin_layout Plain Layout

relate var to atn across R626;
\end_layout

\begin_layout Plain Layout

create object instance dus of DUS;
\end_layout

\begin_layout Plain Layout

relate dus to var across R624;
\end_layout

\begin_layout Plain Layout

select one type related by self->TYPE[R123];
\end_layout

\begin_layout Plain Layout

relate type to dus across R625;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Non-referential Attribute:instantiate()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Object
\end_layout

\begin_layout Standard
"An object is an abstraction of a set of real-world things such that:
\end_layout

\begin_layout Itemize
all the things in the set, the instances, have the same characteristics,
 and 
\end_layout

\begin_layout Itemize
all instances are subject to and conform to the same set of rules and policies."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
domain_name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Determines if the named subtype is this object or part of this object's
 subtyping hierarchy.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

rc = false;
\end_layout

\begin_layout Plain Layout

if (self.name == param.subtype)
\end_layout

\begin_layout Plain Layout

	rc = true;
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

	select many sups related by self->SUP[R134];
\end_layout

\begin_layout Plain Layout

	for each sup in sups
\end_layout

\begin_layout Plain Layout

		rc = sup.hasSubtype( subtype:param.subtype );
\end_layout

\begin_layout Plain Layout

		if (rc)
\end_layout

\begin_layout Plain Layout

			break;
\end_layout

\begin_layout Plain Layout

		end if;
\end_layout

\begin_layout Plain Layout

	end for;
\end_layout

\begin_layout Plain Layout

end if; 
\end_layout

\begin_layout Plain Layout

return rc;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
bool Object:hasSubtype()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Object Attribute
\end_layout

\begin_layout Standard
An object attribute applies to all instances of the object across any subset
 boundaries.
 It is a non-specializer.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
**
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

object_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*domain_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
**
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Object Instance
\end_layout

\begin_layout Standard
A set member.
 e.g., an instantiation of an object as a specified value.
\end_layout

\begin_layout Standard
NOTE: The term, "specified value", indicates that all the attributes of
 the subset have been assigned values.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id A unique identifier for the instance within the domain.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
subset_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
type_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

value_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Satisfies deleting all relationships to this instance and all related instance
 data, such as attribute instances, method instances, and state machines.
 Doesn't delete this instance.
 That must be handled by the caller.
 The architecture domain should call this at the end of processing a deletion
 state.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one sub related by self->SUB[R112];
\end_layout

\begin_layout Plain Layout

// Cleanup relationships
\end_layout

\begin_layout Plain Layout

select many rins related by self->RIN[R120.''is related to''];
\end_layout

\begin_layout Plain Layout

for each rin in rins
\end_layout

\begin_layout Plain Layout

	select one ins related by rin->INS[R120.''is related to''];
\end_layout

\begin_layout Plain Layout

	unrelate self from ins across R120.''is related to'' using rin;
\end_layout

\begin_layout Plain Layout

	rin.delete();
\end_layout

\begin_layout Plain Layout

	delete object instance rin;
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\begin_layout Plain Layout

// Cleanup attributes
\end_layout

\begin_layout Plain Layout

select many atns related by self->ATN[R643];
\end_layout

\begin_layout Plain Layout

for each atn in atns
\end_layout

\begin_layout Plain Layout

	unrelate self from atn across R643;
\end_layout

\begin_layout Plain Layout

	atn.delete();
\end_layout

\begin_layout Plain Layout

	delete object instance atn;
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\begin_layout Plain Layout

// Cleanup methods
\end_layout

\begin_layout Plain Layout

select many ains related by self->AIN[R648];
\end_layout

\begin_layout Plain Layout

for each ain in ains
\end_layout

\begin_layout Plain Layout

	ain.delete();
\end_layout

\begin_layout Plain Layout

	delete object instance ain;
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\begin_layout Plain Layout

// Cleanup state machines
\end_layout

\begin_layout Plain Layout

select one lsm related by self->LSM[R361];
\end_layout

\begin_layout Plain Layout

if (not empty lsm)
\end_layout

\begin_layout Plain Layout

	lsm.delete();
\end_layout

\begin_layout Plain Layout

	delete object instance lsm;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

// Cleanup self unrelate self from sub across R112;
\end_layout

\begin_layout Plain Layout

select many itns related by self->ITN[R101];
\end_layout

\begin_layout Plain Layout

for each itn in itns
\end_layout

\begin_layout Plain Layout

	select one id related by itn->ID[R101];
\end_layout

\begin_layout Plain Layout

	unrelate self from id across R101 using itn;
\end_layout

\begin_layout Plain Layout

	delete object instance itn;
\end_layout

\begin_layout Plain Layout

end for; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Object Instance:delete()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Object Specialization
\end_layout

\begin_layout Standard
An object specialization is any means of subsetting a set defined by an
 object into specialized instances.
 The specialization can occur via data or behavior.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id A unique identifier for the specialization.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
supertype_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
subtype_name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Proper subset
\end_layout

\begin_layout Standard
A proper subset is not equal to the containing set.
 If the boundaries of the set aren't considered to be a partition, then
 a proper subset exists whenever a set is partitioned.
\end_layout

\begin_layout Standard
It should be noted that a proper subset can have all the attributes and
 behavior of the containing set, but still be a proper subset if there exists
 another proper subset of the same set with different attributes and/or
 behavior.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Determines if this subset's state model segment is a peer state model segment.
 This routine checks for a supertype partitioning across R122, then gets
 the supertype object(s) across R114 and determines if there is an associated
 state model segment.
 If there is no associated state model segment, then this method calls itself
 to recurse through the supertype object's hierarchy.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Determine if this is a peer segment.
 i.e., not a splice
\end_layout

\begin_layout Plain Layout

peer = true;
\end_layout

\begin_layout Plain Layout

// Get supertyping
\end_layout

\begin_layout Plain Layout

select one sub related by self->SUB[R107];
\end_layout

\begin_layout Plain Layout

select any sup related by sub->PRP[R107]->SUP[R122];
\end_layout

\begin_layout Plain Layout

if (not empty sup)
\end_layout

\begin_layout Plain Layout

	select many sups related by sub->PRP[R107]->SUP[R122];
\end_layout

\begin_layout Plain Layout

	for each sup in sups
\end_layout

\begin_layout Plain Layout

		// Get subertype object
\end_layout

\begin_layout Plain Layout

		select one prp related by sup->PRP[R114];
\end_layout

\begin_layout Plain Layout

		if (not empty prp)
\end_layout

\begin_layout Plain Layout

			// Does this subtype have a state model segment?
\end_layout

\begin_layout Plain Layout

			select any sps related by prp->SBT[R122]->OBS[R126]->SPS[R125];     
  
\end_layout

\begin_layout Plain Layout

			if (not empty sps)
\end_layout

\begin_layout Plain Layout

				peer = false;
\end_layout

\begin_layout Plain Layout

			else
\end_layout

\begin_layout Plain Layout

				peer = prp.hasPeerSegment();
\end_layout

\begin_layout Plain Layout

			end if;
\end_layout

\begin_layout Plain Layout

			if (not peer)
\end_layout

\begin_layout Plain Layout

				break;
\end_layout

\begin_layout Plain Layout

			end if;
\end_layout

\begin_layout Plain Layout

		end if;
\end_layout

\begin_layout Plain Layout

	end for;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

return peer; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
boolean Proper subset:hasPeerSegment()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Referential Attribute
\end_layout

\begin_layout Standard
"Referential attributes are used to tie an instance of one object to the
 instance of another."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
referenced_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
identifier_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
relationship_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
relationship_number:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Specializing Attribute
\end_layout

\begin_layout Standard
A specializing attribute is one that applies only to some instances of an
 object.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
subtype_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

specialization_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Specializing Segment
\end_layout

\begin_layout Standard
A specializing segment applies to only a subset of instances of the object.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

segment_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*specialization_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Subsequent Specialization
\end_layout

\begin_layout Standard
A subsequent specialization occurs due to other specializations.
 It shows that the subset exists without being linked to a specific metamodel
 element.
\end_layout

\begin_layout Standard
The subsequent specialization can be due to specialization of the subtype
 leaf with no other differentiator at its own level.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*specialization_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Subset
\end_layout

\begin_layout Standard
A proper subset represents a partitioning of a set or, in the case of an
 intersection, multiple sets.
 An improper subset represents the entire set, so an object can also be
 classified as subset.
\end_layout

\begin_layout Standard
In OOA terms, a subtype always implies a subset, so set theory terms are
 used to provide better paths to common relationships in the metamodel.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

keyletters:string Keyletters allow one to be lazy about referring to a subset.
\end_layout

\begin_layout Description
*name:string A name of the subset, that is unique in the domain.
 For an improper subset, this will be the name of the object, but for a
 proper subset, it will be a name, that is a sub-classification of, the
 object name.
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

rc =false;
\end_layout

\begin_layout Plain Layout

select one obj related by self->OBJ[R107];
\end_layout

\begin_layout Plain Layout

if (not empty obj)
\end_layout

\begin_layout Plain Layout

	if (obj.domain_name == param.domain) 
\end_layout

\begin_layout Plain Layout

		rc = true;
\end_layout

\begin_layout Plain Layout

	end if;
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

	select one prp related by self->PRP[R107];
\end_layout

\begin_layout Plain Layout

	// Check for root supertype.
\end_layout

\begin_layout Plain Layout

	select one obj related by prp->NSB[R108]->SUP[R136]->OBJ[R134];
\end_layout

\begin_layout Plain Layout

	while (empty obj)
\end_layout

\begin_layout Plain Layout

		select many itss related by prp->ISB[R108]->ITS[R135];
\end_layout

\begin_layout Plain Layout

		for each its in itss
\end_layout

\begin_layout Plain Layout

			if (its.domain_name == param.domain)
\end_layout

\begin_layout Plain Layout

				rc = true;
\end_layout

\begin_layout Plain Layout

				break;
\end_layout

\begin_layout Plain Layout

			end if;
\end_layout

\begin_layout Plain Layout

		end for;
\end_layout

\begin_layout Plain Layout

		if (not rc)
\end_layout

\begin_layout Plain Layout

			// Move up to next subtyping
\end_layout

\begin_layout Plain Layout

			select one prp related by prp->NSB[R108]->SUP[R136]->PRP[R114];
\end_layout

\begin_layout Plain Layout

			// Check for root supertype.
\end_layout

\begin_layout Plain Layout

			select one obj related by prp->NSB[R108]->SUP[R136]->OBJ[R134];
\end_layout

\begin_layout Plain Layout

		end if;
\end_layout

\begin_layout Plain Layout

	end while;
\end_layout

\begin_layout Plain Layout

	if (not rc and (obj.domain_name == param.domain))
\end_layout

\begin_layout Plain Layout

		rc = true;
\end_layout

\begin_layout Plain Layout

	end if;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

return rc; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
boolean Subset:isSubInDomain()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Returns true if the type of state model specified already exists for the
 subset.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

rc = true;
\end_layout

\begin_layout Plain Layout

if (param.assigner)
\end_layout

\begin_layout Plain Layout

	select one asr related by self->ASR[R354];
\end_layout

\begin_layout Plain Layout

	if (not empty asr)
\end_layout

\begin_layout Plain Layout

		rc = false;
\end_layout

\begin_layout Plain Layout

	end if;
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

	select one lif related by self->LIF[R347];
\end_layout

\begin_layout Plain Layout

	if (not empty lif)
\end_layout

\begin_layout Plain Layout

		rc = false;
\end_layout

\begin_layout Plain Layout

	end if;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

return rc;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
bul Subset:hasStateModel()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Instantiate attributes associated directly with this subset, and then get
 the next level subsets and tell them to instantiate their attributes.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one obj related by self->OBJ[R107];
\end_layout

\begin_layout Plain Layout

if (not empty obj)
\end_layout

\begin_layout Plain Layout

	select many oas related by obj->OA[R129];
\end_layout

\begin_layout Plain Layout

	for each oa in oas
\end_layout

\begin_layout Plain Layout

		select one nra related by oa->ATR[R124]->NRA[R103];
\end_layout

\begin_layout Plain Layout

		select one type related by nra->TYPE[R123];
\end_layout

\begin_layout Plain Layout

		nra.instantiate( objectInstance:param.objectInstance );
\end_layout

\begin_layout Plain Layout

	end for;
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

	select one prp related by self->PRP[R107];
\end_layout

\begin_layout Plain Layout

	select many spas related by prp->SPA[R130];
\end_layout

\begin_layout Plain Layout

	for each spa in spas
\end_layout

\begin_layout Plain Layout

		select one nra related by spa->ATR[R124]->NRA[R103];
\end_layout

\begin_layout Plain Layout

		select one type related by nra->TYPE[R123];
\end_layout

\begin_layout Plain Layout

		nra.instantiate( objectInstance:param.objectInstance );
\end_layout

\begin_layout Plain Layout

	end for;
\end_layout

\begin_layout Plain Layout

	select many sups related by prp->SUP[R122];
\end_layout

\begin_layout Plain Layout

	for each sup in sups
\end_layout

\begin_layout Plain Layout

		select one sub related by sup->OBJ[R134]->SUB[R107];
\end_layout

\begin_layout Plain Layout

		if (empty sub)
\end_layout

\begin_layout Plain Layout

			select one sub related by sup->PRP[R114]->SUB[R107];
\end_layout

\begin_layout Plain Layout

		end if;
\end_layout

\begin_layout Plain Layout

		sub.instantiateAttributes( objectInstance:param.objectInstance );
\end_layout

\begin_layout Plain Layout

	end for;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Subset:instantiateAttributes()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Finds identifiers in this subtype and creates referential identifiers, then
 finds any higher-level sub/supertypes and repeats the operation.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select any irl from instances of IRL where selected.number == param.relationship;
\end_layout

\begin_layout Plain Layout

// First collect any identifiers for this subtype
\end_layout

\begin_layout Plain Layout

irl.createReferentials( objectName:self.name );
\end_layout

\begin_layout Plain Layout

// Then search up the hierarchy until the root supertype is found.
\end_layout

\begin_layout Plain Layout

select one obj related by self->OBJ[R107];
\end_layout

\begin_layout Plain Layout

if (empty obj)
\end_layout

\begin_layout Plain Layout

	select one prp related by self->PRP[R107];
\end_layout

\begin_layout Plain Layout

	select many sups related by prp->SUP[R122];
\end_layout

\begin_layout Plain Layout

	for each sup in sups
\end_layout

\begin_layout Plain Layout

		select one sub related by sup->OBJ[R134]->SUB[R107];
\end_layout

\begin_layout Plain Layout

		if (empty sub)
\end_layout

\begin_layout Plain Layout

			select one sub related by sup->PRP[R114]->SUB[R107];
\end_layout

\begin_layout Plain Layout

		end if;
\end_layout

\begin_layout Plain Layout

		sub.associateReferentials( relationship:param.relationship );
\end_layout

\begin_layout Plain Layout

	end for;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Subset:associateReferentials()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Checks to see if this subset is a member of the named set (object).
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

rc = false;
\end_layout

\begin_layout Plain Layout

select one obj related by self->OBJ[R107] where selected.name == param.object;
\end_layout

\begin_layout Plain Layout

if (not empty obj)
\end_layout

\begin_layout Plain Layout

	rc = true;
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

	select one nsb related by self->PRP[R107]->NSB[R108];
\end_layout

\begin_layout Plain Layout

	if (not empty nsb)
\end_layout

\begin_layout Plain Layout

		select one obj related by nsb->SUP[R136]->OBJ[R134] where selected.name
 == param.object;
\end_layout

\begin_layout Plain Layout

		if (not empty obj)
\end_layout

\begin_layout Plain Layout

			rc = true;
\end_layout

\begin_layout Plain Layout

		else
\end_layout

\begin_layout Plain Layout

			select one sub related by nsb->SUP[R136]->PRP[R114]->SUB[R107];
\end_layout

\begin_layout Plain Layout

			rc = sub.isSubsetOf( object:param.object );
\end_layout

\begin_layout Plain Layout

		end if;
\end_layout

\begin_layout Plain Layout

	else
\end_layout

\begin_layout Plain Layout

		select one isb related by self->PRP[R107]->ISB[R108];
\end_layout

\begin_layout Plain Layout

		select any obj related by isb->OBJ[R135] where selected.name == param.object;
\end_layout

\begin_layout Plain Layout

		if (not empty obj)
\end_layout

\begin_layout Plain Layout

			rc = true;
\end_layout

\begin_layout Plain Layout

		end if;
\end_layout

\begin_layout Plain Layout

	end if;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

return rc; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
boolean Subset:isSubsetOf()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one obj related by self->OBJ[R107];
\end_layout

\begin_layout Plain Layout

if (not empty obj)
\end_layout

\begin_layout Plain Layout

	select many nms related by obj->NM[R131];
\end_layout

\begin_layout Plain Layout

	for each nm in nms
\end_layout

\begin_layout Plain Layout

		select one im related by nm->IM[R533];
\end_layout

\begin_layout Plain Layout

		im.instantiate( objectInstance:param.objectInstance );
\end_layout

\begin_layout Plain Layout

	end for;
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

	select one prp related by self->PRP[R107];
\end_layout

\begin_layout Plain Layout

	select many smts related by prp->SBT[R122]->OBS[R126]->SMT[R125];
\end_layout

\begin_layout Plain Layout

	for each smt in smts
\end_layout

\begin_layout Plain Layout

		select one im related by smt->IM[R533];
\end_layout

\begin_layout Plain Layout

		im.instantiate( objectInstance:param.objectInstance );
\end_layout

\begin_layout Plain Layout

	end for;
\end_layout

\begin_layout Plain Layout

	select many sups related by prp->SUP[R122];
\end_layout

\begin_layout Plain Layout

	for each sup in sups
\end_layout

\begin_layout Plain Layout

		select one sub related by sup->OBJ[R134]->SUB[R107];
\end_layout

\begin_layout Plain Layout

		if (empty sub)
\end_layout

\begin_layout Plain Layout

			select one sub related by sup->PRP[R114]->SUB[R107];
\end_layout

\begin_layout Plain Layout

		end if;
\end_layout

\begin_layout Plain Layout

		sub.instantiateMethods( objectInstance:param.objectInstance );
\end_layout

\begin_layout Plain Layout

	end for;
\end_layout

\begin_layout Plain Layout

end if; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Subset:instantiateMethods()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Subtyping
\end_layout

\begin_layout Standard
Subtyping is the defining of subsets via a supertype partitioning.
 The relationship is abstracted to capture the many to many condition that
 arises from an intersection of two objects.
\end_layout

\begin_layout Standard
On the object model, the subtyping is the leg from the supertype part of
 the relationship to the subtype object.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*supertype_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*subtype_name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Supertype
\end_layout

\begin_layout Standard
A supertype represents a partitioning of the set associated with a specialized
 object.
 The supertype isn't a subset of the object, but can collect a subset of
 attributes that are shared by the subsets formed by the supertype's partitionin
g.
\end_layout

\begin_layout Standard
The representation of the metamodel supertype on the object model is the
 part of the supertype/subtype relationship attached to the supertype object,
 not the supertype object itself.
 
\end_layout

\begin_layout Standard
The identifier for the supertype is the name of the graphical relationship,
 that denotes the subtyping.
 i.e., the relationship with the bar across it in the Shlaer-Mellor notation,
 or the relationship with the triangle on the end in the UML notation.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:string
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

rc = false;
\end_layout

\begin_layout Plain Layout

select any prp related by self->PRP[R122] where selected.name == param.subtype;
\end_layout

\begin_layout Plain Layout

if (not empty prp)
\end_layout

\begin_layout Plain Layout

	rc = true;
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

	select many sups related by self->PRP[R122]->SUP[R114];
\end_layout

\begin_layout Plain Layout

	for each sup in sups
\end_layout

\begin_layout Plain Layout

		rc = sup.hasSubtype( subtype:param.subtype );
\end_layout

\begin_layout Plain Layout

		if (rc)
\end_layout

\begin_layout Plain Layout

			break;
\end_layout

\begin_layout Plain Layout

		end if;
\end_layout

\begin_layout Plain Layout

	end for;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

return rc;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
boolean Supertype:hasSubtype()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Section
Relationship Descriptions
\end_layout

\begin_layout Description
R101 An identifier uniquely identifies instances when an object is instantiated.
 The instance might have multiple identifiers, each of which provides a
 separate path to identification of the instance.
 
\end_layout

\begin_layout Description
R102 An identifier is composed of one or more attributes.
 Since the identifier applies to only one instance, the attributes used
 can compose many identifiers, so each identification is abstracted as an
 object.
\end_layout

\begin_layout Description
R103 Attributes can be non-referential, which means they are used to give
 value or identification to an instance of an object, or referential, which
 means they are used to identify the instances related to the instance of
 an object.
\end_layout

\begin_layout Description
R105 An object inhabits only one modeled domain.
 The modeled domain can contain many objects, but always has at least one.
\end_layout

\begin_layout Description
R107 Subsets are classified as proper or improper subsets.
 Improper subsets are an entire set, which is known in Shlaer-Mellor terms
 as an object.
 This partitioning allows an association between object instance and subset,
 which allows the object instance object to represent an instance member
 of an unspecialized object or an instance member of a subset of a specialized
 object.
\end_layout

\begin_layout Description
R108 Proper subsets are formed by partitioning of a single set or partitioning
 by intersection of more than one set.
\begin_inset Newline newline
\end_inset

Making this distinction is important to establish less ambiguous relationships
 in the model with regard to multiplicities between objects, subsets, attributes
 and instances.
\end_layout

\begin_layout Description
R112 An instance is a member of one subset.
 The subset can contain many instances, or no instances in the case where
 an object hasn't been instantiated for that subset.
 This supports the concept of the empty set.
\end_layout

\begin_layout Description
R114 A proper subset can be partitioned by supertype partitioning.
 As the subset is already formed by a partition, this is referred to as
 multi-level partitioning.
 In the case where the subset is partitioned by more than one supertype,
 it is called multi-way partitioning.
\end_layout

\begin_layout Description
R120 Instances are related to other instances when a relationship is instantiate
d.
\end_layout

\begin_layout Description
R122 Subsets are formed by supertype partitioning, and a subset is a subtype
 for one or more supertypes.
 The partitioning relationship is thus abstracted as a subtyping.
\begin_inset Newline newline
\end_inset

Non-intersecting subtypes are further constrained by R136 to belong to only
 one supertype.
\begin_inset Newline newline
\end_inset

"OOA does not permit creating an instance of the supertype without creating
 an instance of one subtype, and vice versa."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Description
R123 Every non-referential attribute adheres to a known type.
 The type imposes type constraints on the attribute.
\begin_inset Newline newline
\end_inset

NOTE: Referential attributes will also have a known type, but those are
 set where they are non-referential attributes.
\end_layout

\begin_layout Description
R124 An attribute can provide unique data about a set, or can provide unique
 data about a subset of a set.
 The latter case is considered a specialization.
\end_layout

\begin_layout Description
R125 An object specialization is a specializing attribute, an intersection
 of objects or a specializing lifecycle segment.
\end_layout

\begin_layout Description
R126 An object specialization results in one subtyping of an object, and
 the subtyping can be the result of multiple defined object specialization
 types.
\begin_inset Newline newline
\end_inset

While a single specialization actually results in two subtypings, additional
 subtypings in the same generalization will not result in two subtypings.
 e.g., An object, A, exists, and it is decided an attribute only applies to
 some instances of A and not others.
 A subtype, B, is created to hold the attribute, and a subtype, C, is created
 to represent the instances without the attribute.
 Another attribute is defined to only apply to some instances of A, so subtype,
 D, is created.
 D requires no subsequent specialization, because the remaining instances
 are already defined by B and C.
\end_layout

\begin_layout Description
R127 A non-referential attribute value can depend upon the value of other
 attributes.
 An attribute can provide value for many dependent attributes.
\begin_inset CommandInset citation
LatexCommand cite
key "OOA96"
literal "false"

\end_inset

 has a discussion on the types of dependencies possible.
\end_layout

\begin_layout Description
R129 An object attribute characterizes an object.
 The object and all subsets of an object are characterized by object attributes,
 as all of the object attributes apply to all instances of the object.
\begin_inset Newline newline
\end_inset

As there is always an identifier attribute, an object is always characterized
 by at least one object attribute.
\end_layout

\begin_layout Description
R130 A specializing attribute always specializes one proper subset.
 A proper subset can be specialized by many specializing attributes.
\end_layout

\begin_layout Description
R128 A referential attribute always formalizes a non-composition, instance
 relationship.
 All non-composition, instance relationships are formalized by one or more
 referential attributes.
 
\end_layout

\begin_layout Description
R131 An object can have defined non-specializing methods, and a non-specializing
 method is defined for one object.
\end_layout

\begin_layout Description
R132 An object can have defined object methods, and an object method is
 defined for one object.
\end_layout

\begin_layout Description
R133 Subset can be related to other subsets.
\end_layout

\begin_layout Description
R134 A supertype can partition an object, or it can a partition a proper
 subset.
 An object is partitioned by one or more supertypes.
\begin_inset Newline newline
\end_inset

A partitioning of an object by a single supertype should be pictured as
 one or more parallel chords, each crossing the arc of the set at two distinct
 points.
\begin_inset Newline newline
\end_inset

When the partitioning of the same object is done by more than one supertype,
 the chords of the supertypes intersect each other.
\end_layout

\begin_layout Description
R135 An intersecting subset is formed from the intersection of two or more
 objects, and an object can be partitioned by more than one intersecting
 subset.
 The intersection associative object tracks each 'subset partitions object'
 association.
 e.g., in the simplest example, a subset C is formed from the intersection
 of object A and object B; two intersections are needed to represent this:
 CA and CB.
 This case has one intersecting subset, two objects, and two intersections.
\end_layout

\begin_layout Description
R136 A non-intersecting subset is a subtype for one supertype, and the supertype
 defines the partitioning for all of its subtypes.
\begin_inset Newline newline
\end_inset

This relationship adds further constraint, for non-intersecting subsets,
 to R122, which defines all of the subtyping relationships.
\end_layout

\begin_layout Description
R137 A referential identifier refers to an attribute participating in identifica
tion of an object instance.
 An identification participant can be referenced by a referential attribute.
\end_layout

\begin_layout Chapter
The Process Subsystem
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Process-Package Diagram.png
	width 70page%

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Process Subsystem Diagram
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Section
Object and Attribute Descriptions
\end_layout

\begin_layout Subsection
Accessor
\end_layout

\begin_layout Standard
An accessor provides access to reference elements and defines the signature
 of the access.
 The accessor represents bridges, events, and operations.
 In other words, things that would be known as functions, procedures, or
 methods in third generation programming languages like C or Java.
\end_layout

\begin_layout Standard
An accessor is a value once instantiated in the metamodel, that can be reference
d in process models.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*name:string
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Create an instance of this accessor, and it's parameters.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

create object instance ain of AIN;
\end_layout

\begin_layout Plain Layout

select any aref from instances of AREF;
\end_layout

\begin_layout Plain Layout

relate ain to aref across R422;
\end_layout

\begin_layout Plain Layout

relate ain to self across R640;
\end_layout

\begin_layout Plain Layout

create object instance val of VAL;
\end_layout

\begin_layout Plain Layout

relate ain to val across R629;
\end_layout

\begin_layout Plain Layout

create object instance dus of DUS;
\end_layout

\begin_layout Plain Layout

relate val to dus across R624;
\end_layout

\begin_layout Plain Layout

select one type related by aref->CORE[R403]->TYPE[R401];
\end_layout

\begin_layout Plain Layout

relate type to dus across R625;
\end_layout

\begin_layout Plain Layout

create object instance re of RE;
\end_layout

\begin_layout Plain Layout

relate dus to re across R514;
\end_layout

\begin_layout Plain Layout

select many prms related by self->PRM[R540];
\end_layout

\begin_layout Plain Layout

for each prm in prms
\end_layout

\begin_layout Plain Layout

	prm.instantiate( accessorInstance:ain.id );
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\begin_layout Plain Layout

return ain.id; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
unique_id Accessor:instantiate()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Action
\end_layout

\begin_layout Standard
"All the processing that goes on in the system is stated in the actions."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
An Action is a single, atomic, unit of processing that can read data, write
 data (implied modify), make conditional choices, and launch the execution
 of other actions.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
element_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Returns the name of the accessor or state that contains this action.
 In the case of states, different event (accessor) names can be used to
 cause entry into the state, so the state name must be used.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

name = "";
\end_layout

\begin_layout Plain Layout

select one acc related by self->AE[R500]->BRG[R509]->ASB[R3]->ASA[R506]->ACC[R50
5];
\end_layout

\begin_layout Plain Layout

if (empty acc)
\end_layout

\begin_layout Plain Layout

	select one acc related by self->AE[R500]->BRG[R509]->SYB[R3]->SYA[R524]->ACC[R5
05];
\end_layout

\begin_layout Plain Layout

	if (empty acc)
\end_layout

\begin_layout Plain Layout

		select one acc related by self->AE[R500]->ATA[R509]->ISY[R534]->SYA[R524]->ACC
[R505];
\end_layout

\begin_layout Plain Layout

		if (empty acc)
\end_layout

\begin_layout Plain Layout

			select one acc related by self->AE[R500]->MTH[R509]->ISY[R534]->SYA[R524]->AC
C[R505];
\end_layout

\begin_layout Plain Layout

			if (empty acc)
\end_layout

\begin_layout Plain Layout

				select one sta related by self->AE[R500]->STA[R509];
\end_layout

\begin_layout Plain Layout

				name = sta.name;
\end_layout

\begin_layout Plain Layout

			end if;
\end_layout

\begin_layout Plain Layout

		end if;
\end_layout

\begin_layout Plain Layout

	end if;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

if (not empty acc)
\end_layout

\begin_layout Plain Layout

	name = acc.name;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

return name;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
string Action:getAccessorName()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Active Element
\end_layout

\begin_layout Standard
An active element is any OOA construct that contains a process model.
 The active element must be accessible from other elements and can access
 other elements.
 The other elements can be internal or external to the domain being modeled.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id
\end_layout

\begin_layout Subsection
Asynchronous Accessor
\end_layout

\begin_layout Standard
An asynchronous accessor executes some time after the action in which it
 was generated completes.
 (see 
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset

 page 131)
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Attribute Action
\end_layout

\begin_layout Standard
An attribute action is used to calculate the value of a derived attribute.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
nra_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Control Structure
\end_layout

\begin_layout Standard
A control structure process is used to encapsulate other process execution.
 Typical control structures are if-then-else and while loops.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
closure_position:real The ordinal position of the last process in the control
 structure.
 A closure position of zero means the control structure is unclosed.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*ordinal_position:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*action_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Element Access
\end_layout

\begin_layout Standard
Element Access represents usage of a modeled element by a Process.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*ordinal_position:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*action_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*referenceElement_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Equation
\end_layout

\begin_layout Standard
An equation is statement of equality using other values or variables.
 In OOA, an equation results in assignment to a variable.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one re related by self->RE[R514];
\end_layout

\begin_layout Plain Layout

unrelate self from re across R514;
\end_layout

\begin_layout Plain Layout

re.delete(); 
\end_layout

\begin_layout Plain Layout

delete object instance re; 
\end_layout

\begin_layout Plain Layout

select many exps related by self->EXP[R622]; 
\end_layout

\begin_layout Plain Layout

for each exp in exps
\end_layout

\begin_layout Plain Layout

	select one tyop related by exp->TYOP[R632];
\end_layout

\begin_layout Plain Layout

	unrelate exp from tyop across R632;
\end_layout

\begin_layout Plain Layout

	select one out related by exp->OUT[R611];
\end_layout

\begin_layout Plain Layout

	unrelate out from exp across R611;
\end_layout

\begin_layout Plain Layout

	select one tyop related by out->TYOP[R634];
\end_layout

\begin_layout Plain Layout

	unrelate out from tyop across R634;
\end_layout

\begin_layout Plain Layout

	select one oprd related by out->OPRD[R618];
\end_layout

\begin_layout Plain Layout

	unrelate out from oprd across R618;
\end_layout

\begin_layout Plain Layout

	delete object instance out;
\end_layout

\begin_layout Plain Layout

	select one rho related by exp->RHO[R617];
\end_layout

\begin_layout Plain Layout

	unrelate exp from rho across R617;
\end_layout

\begin_layout Plain Layout

	select one oprd related by rho->OPRD[R615];
\end_layout

\begin_layout Plain Layout

	unrelate rho from oprd across R615;
\end_layout

\begin_layout Plain Layout

	delete object instance rho;
\end_layout

\begin_layout Plain Layout

	select one dus related by oprd->DUS[R631];
\end_layout

\begin_layout Plain Layout

	unrelate oprd from dus across R631;
\end_layout

\begin_layout Plain Layout

	delete object instance oprd;
\end_layout

\begin_layout Plain Layout

	select one lho related by exp->LHO[R616];
\end_layout

\begin_layout Plain Layout

	if (not empty lho)
\end_layout

\begin_layout Plain Layout

		unrelate exp from lho across R616;
\end_layout

\begin_layout Plain Layout

		select one oprd related by lho->OPRD[R615];
\end_layout

\begin_layout Plain Layout

		unrelate lho from oprd across R615;
\end_layout

\begin_layout Plain Layout

		delete object instance lho;
\end_layout

\begin_layout Plain Layout

		select one dus related by oprd->DUS[R631];
\end_layout

\begin_layout Plain Layout

		unrelate oprd from dus across R631;
\end_layout

\begin_layout Plain Layout

		delete object instance oprd;
\end_layout

\begin_layout Plain Layout

	end if;
\end_layout

\begin_layout Plain Layout

	unrelate self from exp across R622;
\end_layout

\begin_layout Plain Layout

	delete object instance exp;
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Equation:delete()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Event
\end_layout

\begin_layout Standard
An event causes a transition to occur in a state machine.
 The event therefore provides access to execute any action caused by the
 transition.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
model_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
state_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
entry_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*object_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Event Parameter
\end_layout

\begin_layout Standard
An event parameter is a parameter assigned to an event.
 The subtype is required for enforcing the "same data rule" for entry into
 a state.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
model_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
state_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*type_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*accessor_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Instance Method
\end_layout

\begin_layout Standard
An instance method requires an instantiation, before it can be used.
 The dynamics of the instance method only apply to a single object instance.
\end_layout

\begin_layout Standard
Instance methods are favored over events when actions need to occur within
 the atomicity of a process.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one acc related by self->MTH[R532]->ISY[R534]->SYA[R524]->ACC[R505];
\end_layout

\begin_layout Plain Layout

instId = acc.instantiate();
\end_layout

\begin_layout Plain Layout

select any ain from instances of AIN where selected.id == instId;
\end_layout

\begin_layout Plain Layout

select any ins from instances of INS where selected.id == param.objectInstance;
\end_layout

\begin_layout Plain Layout

create object instance min of MIN;
\end_layout

\begin_layout Plain Layout

relate ain to ins across R648 using min;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Instance Method:instantiate()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Internal Synchronous
\end_layout

\begin_layout Standard
Internal synchronous accesses actions inside the domain being modeled.
\end_layout

\begin_layout Standard
NOTE: It is legal for the domain being modeled to call its own synchronous
 service as well.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Iteration
\end_layout

\begin_layout Standard
An iteration process steps through an ordinal value from a specified starting
 point to a specified ending point.
 Typical iteration processes in third generation programming languages are
 for loops.
\end_layout

\begin_layout Standard
This analysis only supports a single step index into a fixed length array,
 therefore the iteration always starts at the first array element (one-based)
 and indexes through the end of the array.
 External editors will have to adjust their value arrays accordingly or
 use a loop.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
current_index:integer This attribute tracks the current position in the
 array whose value is contained in the variable.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*ordinal_position:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*action_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Loop
\end_layout

\begin_layout Standard
A loop process performs any contained processes until a specified condition
 is met.
 Typical loop processes in third generation programming languages are while
 and do-while statements.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*ordinal_position:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*action_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Method
\end_layout

\begin_layout Standard
Objects can have methods associated with them to handle synchronous processing
 tasks.
\end_layout

\begin_layout Standard
In Object Lifecycles
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset

, methods weren't explicitly called as such, but the processes used in the
 process models were explicitly tied to an object and available for reuse
 in many process models.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

rc = true;
\end_layout

\begin_layout Plain Layout

select one om related by self->OM[R532] where selected.name == param.object;
\end_layout

\begin_layout Plain Layout

if (empty om)
\end_layout

\begin_layout Plain Layout

	select one nm related by self->IM[R532]->NM[R533] where selected.name ==
 param.object;
\end_layout

\begin_layout Plain Layout

	if (empty nm)
\end_layout

\begin_layout Plain Layout

		select one obs related by self->IM[R532]->SMT[R533]->OBS[R125] where selected.s
ubtype_name == param.object;
\end_layout

\begin_layout Plain Layout

		if (empty obs)
\end_layout

\begin_layout Plain Layout

			rc = false;
\end_layout

\begin_layout Plain Layout

		end if;
\end_layout

\begin_layout Plain Layout

	end if;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

return rc;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
boolean Method:belongsTo()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Non-event Parameter
\end_layout

\begin_layout Standard
A non-event parameter is assigned to any accessor that isn't an event.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*type_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*accessor_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Non-specializing Method
\end_layout

\begin_layout Standard
A non-specializing instance method applies to all instantiations of an object,
 regardless of subtyping.
\end_layout

\begin_layout Standard
In the object model, these appear in unspecialized objects and root supertypes
 of specialized objects only.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*object_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*domain_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Object Method
\end_layout

\begin_layout Standard
An object method doesn't require an instantiation to be invoked.
 It is the method analog to the assigner state machine.
 It is used for encapsulating synchronous object dynamics that aren't specific
 to an object instance.
\end_layout

\begin_layout Standard
Typical usage of an object method is to initialize an instance unconditionally
 related to another instance in cases where actions must be performed upon
 creation of the instance.
 Such a condition can't use state machine creation, as the asynchronous
 nature violates the unconditional aspect of the relationship.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*object_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*domain_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Parameter
\end_layout

\begin_layout Standard
A parameter specifies a typed data instance whose value is accessible by
 the action associated with the accessor.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*name:string
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*type_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*accessor_name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Create an instance of this parameter related to the specified accessor instance.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select any ain from instances of AIN where selected.id == param.accessorInstance;
\end_layout

\begin_layout Plain Layout

create object instance prn of PRN;
\end_layout

\begin_layout Plain Layout

relate prn to self across R645;
\end_layout

\begin_layout Plain Layout

relate prn to ain across R647;
\end_layout

\begin_layout Plain Layout

create object instance var of VAR;
\end_layout

\begin_layout Plain Layout

relate prn to var across R626;
\end_layout

\begin_layout Plain Layout

select any emp from instances of EMP;
\end_layout

\begin_layout Plain Layout

select one val related by emp->VAL[R629];
\end_layout

\begin_layout Plain Layout

relate val to var across R635;
\end_layout

\begin_layout Plain Layout

create object instance dus of DUS;
\end_layout

\begin_layout Plain Layout

relate var to dus across R624;
\end_layout

\begin_layout Plain Layout

select one type related by self->TYPE[R541];
\end_layout

\begin_layout Plain Layout

relate dus to type across R625;
\end_layout

\begin_layout Plain Layout

create object instance re of RE;
\end_layout

\begin_layout Plain Layout

relate dus to re across R514;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Parameter:instantiate()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Path Assignment
\end_layout

\begin_layout Standard
A path assignment is done by the path evaluation control structure to assign
 the nested process to a specific path.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*nesting_ordinal_position:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*nesting_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*path_ordinal_position:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*path_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Path Evaluation
\end_layout

\begin_layout Standard
A path evaluation process evaluates one or more expressions and chooses
 the processes to execute.
 Typical path evaluation processes in third generation programming languages
 are if-then-else and switch-case statements.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
numPaths:integer The number of unique paths in this control structure.
 Examples: 
\begin_inset Newline newline
\end_inset

an if statement has one path 
\begin_inset Newline newline
\end_inset

an if-else statement has two paths 
\begin_inset Newline newline
\end_inset

an if-elif-else statement has three paths 
\begin_inset Newline newline
\end_inset

a switch-case statement has paths equal to the number of cases
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*ordinal_position:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*action_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Process
\end_layout

\begin_layout Standard
A Process is a single execution statement in a textual model, or a single
 flow in a graphical model.
 It can read data, write data (implied modify), make a conditional path
 choice, and execute another process model.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*ordinal_position:real The position of the process in the action.
 The ordinal positions of processes determine sequence of execution when
 the action is invoked.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*action_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Process Nesting
\end_layout

\begin_layout Standard
A process nesting is a process contained within a control structure.
 The control structure determines when the process is executed.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*controlStructure_ordinal_position:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*controlStructure_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*process_ordinal_position:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*process_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Reference Element
\end_layout

\begin_layout Standard
A reference element is any Shlaer-Mellor element that can be accessed as
 part of a procedural model.
 A reference element invokes an action and/or assigns a value to a variable.
\end_layout

\begin_layout Standard
The reference element constrains which elements in the metamodel can participate
 in a process.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id
\end_layout

\begin_layout Subsection
Return Value
\end_layout

\begin_layout Standard
A return value specifies a type defined for an access that returns a data
 value.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*type_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*access_name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Specializing Method
\end_layout

\begin_layout Standard
A specializing instance method exists in only a subset of object instantiations.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
**
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

specialization_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Statement
\end_layout

\begin_layout Standard
A statement process executes a single expression.
 It doesn't contain other processes.
 The typical executions are assignment, event generation, or external action
 calls.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*ordinal_position:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*action_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Synchronous Accessor
\end_layout

\begin_layout Standard
A synchronous accessor executes during the time that the action is running.
 (see 
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset

 page 131) 
\end_layout

\begin_layout Standard
Only synchronous accessors can return a value.
 Action is suspended until the value is returned.
 This means that a synchronous service provided by another domain can launch
 asynchronous actions to obtain the return value, but this domain will be
 blocked while waiting on the actions to complete.
 The analyst should take this into consideration.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Section
Relationship Descriptions
\end_layout

\begin_layout Description
R500 An Active Element is the container for the Action.
 The Active Element provides access, either internal or external, for launching
 the Action.
\end_layout

\begin_layout Description
R501 The Action executes Processes upon launch.
 The Processes are unique for the Action.
 Reuse of Processes is achieved by Actions launching other Actions via their
 Active Element.
\end_layout

\begin_layout Description
R502 Processes can use one or more Referenced Elements for data access and
 Action execution.
\end_layout

\begin_layout Description
R505 An accessor is an asynchronous accessor or a synchronous accessor.
\end_layout

\begin_layout Description
R506 A synchronous accessor requires asynchronous action from an internal
 event or an external domain.
\end_layout

\begin_layout Description
R509 Only certain elements of OOA modeling can contain process models and
 therefore are active elements.
\end_layout

\begin_layout Description
R514 Only certain elements of OOA can be referenced by process models, so
 those elements are constrained by this relationship.
\end_layout

\begin_layout Description
R522 An attribute action uses the derivations defined for an attribute to
 calculate the attribute's value.
 The derivations are only used by one attribute action.
\end_layout

\begin_layout Description
R523 An attribute action is defined for providing a value for only one non-refer
ential attribute.
 Not all non-referential attributes have their value derived.
\end_layout

\begin_layout Description
R524 A synchronous accessor requires synchronous action from internal processing
 or an external domain.
\end_layout

\begin_layout Description
R529 A type can be used to constrain returns from synchronous accesses,
 and a synchronous access can return a specified data type.
\end_layout

\begin_layout Description
R532 Methods can be applied to instantiated object instances or uninstantiated
 objects.
\end_layout

\begin_layout Description
R533 An instance method can exist for all objects instances or only a subset
 of object instances.
\end_layout

\begin_layout Description
R534 An internal, synchronous accessor is either a method or an attribute
 action.
\end_layout

\begin_layout Description
R535 An event is accessed via a subset, and a subset can provide access
 for many events.
\end_layout

\begin_layout Description
R536 Processes are single statements or control structures that contain
 other processes.
\end_layout

\begin_layout Description
R537 The control structures supported in this analysis are path evaluation,
 iteration, and loops.
\end_layout

\begin_layout Description
R538 A control structure controls zero to many processes, and a process
 can have its execution controlled by a control structure.
 Another way to look at this relationship is as containment where a control
 structure can contain other processes.
 Scoping is avoided in this analysis as variables are scoped by the action,
 not by any processes.
\end_layout

\begin_layout Description
R539 A path evaluation assigns its nested processes to specific paths.
\end_layout

\begin_layout Description
R540 An accessor can have parameters assigned to it.
 A parameter is always assigned to an accessor.
\end_layout

\begin_layout Description
R541 A parameter is constrained by a type, and a type can constrain many
 parameters.
\end_layout

\begin_layout Description
R542 A parameter is either an event parameter or a non-event parameter.
 The event parameter subtype is required to enforce the "same data rule"
 on entry into a state.
\end_layout

\begin_layout Chapter
The Relationship Subsystem
\end_layout

\begin_layout Standard
The subsystem of the metamodel concerning relationships.
\end_layout

\begin_layout Standard
This diagram borrows heavily from the miUML
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset

 metamodel, because why reinvent the open-sourced wheel? The key differences
 are the extra level of abstraction due to instance representation in this
 metamodel, and the lack of a generalization relationship in this metamodel;
 generalizations aren't relationships in this metamodel.
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Relationship-Package Diagram.png
	width 70page%

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Relationship Subsystem Diagram
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Section
Object and Attribute Descriptions
\end_layout

\begin_layout Subsection
Active Perspective
\end_layout

\begin_layout Standard
"A Binary Association has two Perspectives, one Active and one Passive Perspecti
ve.
 In fact, the two sides of an Association could have just as easily been
 designated as the A side and the B side.
 Using the terms Active / Passive offers the modeler a systematic way to
 choose the phrase to apply to each side.
 For example, the phrase pair configures / is configured by readily establishes
 the Perspective sides.
\end_layout

\begin_layout Standard
If it’s not clear from the phrase names which side should be active or passive,
 then arbitrarily assign each role and be done with it.
 You can always query the metamodel later to find out which is which.
 Any miUML class diagram editor should provide easy UI access to this query
 (highlight the A/P sides)."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
Rid:same_as<Base_Attribute>
\end_layout

\begin_layout Description
Rnumber:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Associative Relationship
\end_layout

\begin_layout Standard
An associative relationship requires further abstraction by an object.
 The set defined by the object allows instances of relationships to have
 further relationships, data properties, and dynamic processing.
\end_layout

\begin_layout Standard
An associative relationship relates the associative object to a relationship
 between object instances.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
object_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
irl_number:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Asymmetric Perspective
\end_layout

\begin_layout Standard
"Each side of a Binary Association has a distinct Perspective, either Active
 or Passive.
 Since each side is from a different point of view, it establishes an Asymmetric
 Perspective."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Binary
\end_layout

\begin_layout Standard
"The term 'binary’ means that there are exactly two perspectives on this
 type of Association.
 It does NOT mean that there are two Classes.
 A reflexive Binary Association may be created on a single Class such that
 each of the two Perspectives is viewed from the same Class."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*number:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Composition
\end_layout

\begin_layout Standard
An instance of composition is the loop segment containing the relationship
 instance that is the result of the composition equation.
\end_layout

\begin_layout Standard
"[When a relationship is the logical consequence of other relationships,]
 Such a relationship is said to be formed by composition (as in composition
 of functions in mathematics.
 [...] A relationship formed by composition cannot be formalized in referential
 attributes, since the connections between the instances is already given
 by the connections between the [composing relationships].
\end_layout

\begin_layout Standard
A relationship formed by composition is annotated on the model as [composed
 relationship = 1st composing relationship + 2nd composing relationship
 [+ nth composing relationship ...]]."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
"Composed Relationships.
 Another special case occurs when the constraint on the referential attribute
 is such that it identifies a single instance of the associated object.
 [...] Composition of relationships captures the constraint directly in data
 [...] However the use of composition is limited in that it requires that the
 constraint always identify a single associated instance."
\begin_inset CommandInset citation
LatexCommand cite
key "OOA96"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
Both definitions identify compositions as relationship combinations that
 loop back to the originating instance.
 miUML
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset

 calls compositions, "Constrained Loops", because the composition equation
 forms a constraint on the object instances allowed to participate.
\end_layout

\begin_layout Standard
OOA '96
\begin_inset CommandInset citation
LatexCommand cite
key "OOA96"
literal "false"

\end_inset

 also discusses collapsed referential identifiers, but the example shows
 them to be an alternative way to draw compositions on the object model.
 This metamodel will only model a composition and leave the way to display
 it up to the model editor.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
loop_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*number:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Composition Loop
\end_layout

\begin_layout Standard
A composition loop is the set of relationships participating in the composition.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id
\end_layout

\begin_layout Subsection
Instance Relationship
\end_layout

\begin_layout Standard
An instance relationship describes the constraints and associations imposed
 on instantiation of related objects.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*number:integer
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
3
\end_layout

\end_inset

left_object_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
3
\end_layout

\end_inset

right_object_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select any sub from instances of SUB where selected.name == param.objectName;
\end_layout

\begin_layout Plain Layout

select many idps related by sub->OBJ[R107]->OA[R129]->ATR[R124]->IDP[R102];
\end_layout

\begin_layout Plain Layout

if (empty idps)
\end_layout

\begin_layout Plain Layout

	select many idps related by sub->PRP[R107]->SPA[R130]->ATR[R124]->IDP[R102];
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

for each idp in idps
\end_layout

\begin_layout Plain Layout

	select one atr related by idp->ATR[R102];
\end_layout

\begin_layout Plain Layout

	create object instance refatr of ATR;
\end_layout

\begin_layout Plain Layout

	refatr.name = atr.name + "(R" + TC::intToString( i:self.number ) + ")";
\end_layout

\begin_layout Plain Layout

	create object instance ref of REF;
\end_layout

\begin_layout Plain Layout

	relate ref to refatr across R103;
\end_layout

\begin_layout Plain Layout

	relate idp to ref across R137;
\end_layout

\begin_layout Plain Layout

	select one ncm related by self->NCM[R213];
\end_layout

\begin_layout Plain Layout

	relate ref to ncm across R128;
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Instance Relationship:createReferentials()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Loop Segment
\end_layout

\begin_layout Standard
A loop segment is a relationship instance participating in a composition
 loop.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*relationship_number:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*loop_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Many Perspective
\end_layout

\begin_layout Standard
This is a Perspective with a multiplicity of many.
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Non-composition
\end_layout

\begin_layout Standard
Per Object Lifecycles
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset

, the basis of the composition definition is the composition of functions
 in mathematics, so a function in this usage is a relationship instance
 that is used to compose the composition relationship instance.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*number:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
One Perspective
\end_layout

\begin_layout Standard
"This is a Perspective with a multiplicity of one."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Passive Perspective
\end_layout

\begin_layout Standard
"A Binary Association has two Perspectives, one Active and one Passive Perspecti
ve.
 In fact, the two sides of an Association could have just as easily been
 designated as the A side and the B side.
 Using the terms Active / Passive offers the modeler a systematic way to
 choose the phrase to apply to each side.
 For example, the phrase pair configures / is configured by readily establishes
 the Perspective sides.
\end_layout

\begin_layout Standard
If it’s not clear from the phrase names which side should be active or passive,
 then arbitrarily assign each role and be done with it.
 You can always query the metamodel later to find out which is which.
 Any miUML class diagram editor should provide easy UI access to this query
 (highlight the A/P sides)."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
Rid:same_as<Base_Attribute>
\end_layout

\begin_layout Description
Rnumber:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Perspective
\end_layout

\begin_layout Standard
"A Perspective is a point of view from a hypothetical Instance on an Association.
"
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
Perspective was taken from the miUML metamodel, which doesn't have an instance
 object, so in this metamodel, instance isn't hypothetical and always has
 a perspective when involved in a relationship.
\end_layout

\begin_layout Standard
Further discussion on perspective can be found in the chapter 4, "Reflexive
 Relationships", in OOA '96
\begin_inset CommandInset citation
LatexCommand cite
key "OOA96"
literal "false"

\end_inset

.
 
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
conditional:boolean
\end_layout

\begin_layout Description
phrase:string
\end_layout

\begin_layout Description
*id:unique_id The unique identifier for the perspective.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

reference_id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Relationship
\end_layout

\begin_layout Standard
"A relationship is an abstraction of a set of associations that hold systematica
lly between different kinds of things in the real world."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
The relationship represents a table containing a row for every instance
 of the relationship, and a column for each object participating in the
 relationship.
 When looking at the object model, the relationship represent the empty
 table.
 In the process model, the rows of the table are populated.
 The rows of the table, then represent relationship instance values.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id
\end_layout

\begin_layout Subsection
Symmetric Perspective
\end_layout

\begin_layout Standard
"A Unary Association has only one Perspective.
 Given two Objects (or the same Object linked to itself) on a Unary Association,
 the role played by either side of the Link is identical.
 There is, consequently, just one Symmetric Perspective.
\end_layout

\begin_layout Standard
Therefore, only one phrase name, one multiplicity and one conditionality
 need be specified for a Unary Association."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
A Unary Association in this metamodel always involves just one Object.
 Unary Association is the same as Symmetric Reflexive Relationship in OOA
 '96
\begin_inset CommandInset citation
LatexCommand cite
key "OOA96"
literal "false"

\end_inset

.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
Rid:same_as<Base_Attribute>
\end_layout

\begin_layout Description
Rnumber:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Symmetric Reflexive
\end_layout

\begin_layout Standard
The symmetric reflexive relationship is described in OOA '96
\begin_inset CommandInset citation
LatexCommand cite
key "OOA96"
literal "false"

\end_inset

.
 A symmetric reflexive relationship has the same multiplicity,conditionality,
 and verb phrase at both ends of the relationship, so those specifiers are
 squished into one perspective.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*id:unique_id
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*number:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Traversal Direction
\end_layout

\begin_layout Standard
The direction set by the perspective on a relationship to use to traverse
 the relationship to the linked object instance.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*relationshipInstance_id:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*perspective_id:same_as<Base_Attribute>
\end_layout

\begin_layout Section
Relationship Descriptions
\end_layout

\begin_layout Description
R200 Two types of relationships exist in a Shlaer-Mellor model: instance-based
 and associative.
\end_layout

\begin_layout Description
R201 The two types of instance-based relationships are unary and binary.
 The designation of unary and binary refer to the number of perspectives
 of the instances involved, and not the number of instances.
\end_layout

\begin_layout Description
R204 A perspective is an asymmetric perspective or symmetric perspective.
\end_layout

\begin_layout Description
R205 An asymmetric perspective can be viewed in active or passive tense.
\end_layout

\begin_layout Description
R206 The symmetric perspective is the view both from and on the unary relationsh
ip.
\end_layout

\begin_layout Description
R207 The active perspective is viewed from one side of the binary relationship.
\end_layout

\begin_layout Description
R208 The passive perspective is viewed from one side of the binary relationship.
\end_layout

\begin_layout Description
R210 "The direction of reference of a Referential Attribute is determined
 by the availability of a One Perspective.
 Conditionality is less significant in this regard.
 So to capture the basic reference rule that ‘it is always possible to refer
 to a One Perspective’ it is necessary to abstract the One / Many specialization.
 See the Formalization Subsystem to see how it is used.
\begin_inset Newline newline
\end_inset

Regardless of conditionality, every Perspective is either One or Many (1,
 M) or, in UML terminology, ( 0..1, 1 or 0..*, 1..* )."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Description
R212 An instance relationship can abstract a single associative relationship,
 but an associative relationship is always abstracted by an instance relationshi
p.
\end_layout

\begin_layout Description
R213 An instance relationship can be a non-composition (formalized by referentia
l attributes) or a composition (formalized by a relationship loop) instance
 relationship.
\end_layout

\begin_layout Description
R214 A composition is bounded by a composition loop.
 The composition loop bounds the composition.
\end_layout

\begin_layout Description
R215 An instance relationship can belong to one or more composition loops.
 The composition loop requires a contiguous, closed path from many instance
 relationships.
\end_layout

\begin_layout Description
R202 An associative relationship is always abstracted by an object or subset
 of an object.
 When an object is used to abstract an associative relationship, it's life
 span is the same as the relationship's life span.
\end_layout

\begin_layout Description
R216 A relationship instance can have traversal direction specified by a
 relationship perspective, and a relationship perspective can specify traversal
 direction for many relationship instances.
\end_layout

\begin_layout Chapter
The Type Subsystem
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Package Diagram.png
	width 70page%

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Type Subsystem Diagram
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Section
Object and Attribute Descriptions
\end_layout

\begin_layout Subsection
Accessor Reference
\end_layout

\begin_layout Standard
An accessor reference is the type to which a variable with an accessor as
 a value must conform.
 In OAL this is an event instance; in C it would be like a function pointer.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
The operations permitted for instance reference data types are:
\end_layout

\begin_layout Itemize
the comparisons = and != (identical and not identical in value)
\end_layout

\begin_layout Itemize
the set existence checks of empty and not empty.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"accessor reference
", result:"accessor reference") to TYOP class;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Accessor Reference:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Accessor Reference-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Accessor Reference State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many arefs from instances of AREF;
\end_layout

\begin_layout Plain Layout

if (cardinality arefs == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   type.name = "accessor reference";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::ACCESSOR_REFERENCE;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of type AREF attempted!");
\end_layout

\begin_layout Plain Layout

   generate AREF2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

  core.destroy();
\end_layout

\begin_layout Plain Layout

  unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

  delete object instance core;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Arbitrary
\end_layout

\begin_layout Standard
"To define a data type for data elements that represent arbitrary identifiers:
 data type <data type name> is arbitrary
\end_layout

\begin_layout Standard
The implementation of an arbitrary type like all the base data types is
 determined by the architecture domain.
 Hence the analyst should make no assumptions as to how this is done: the
 arbitrary type may be implemented as a handle, an integer, a character
 string, or by any other scheme the architects devise.
 For this reason, the analyst cannot specify a default value for the base
 data type arbitrary."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
The OOA of Data
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset

 prescribes no operators for arbitrary.
 Arbitrary is treated like a composite, where the internals are unknown,
 so the only valid operations permitted using data types based on arbitrary
 are limited to equality comparison and assignment to another arbitrary
 type.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"arbitrary",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"equal", symbol:"=", type:"arbitrary", result:"bool
ean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"arbitrary",
 result:"boolean") to TYOP class;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Arbitrary:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Arbitrary-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Arbitrary State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many arids from instances of ARID;
\end_layout

\begin_layout Plain Layout

if (cardinality arids == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   type.name = "arbitrary";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::ARBITRARY;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of ARID attempted!");
\end_layout

\begin_layout Plain Layout

   generate ARID2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

  core.destroy();
\end_layout

\begin_layout Plain Layout

  unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

  delete object instance core;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Boolean
\end_layout

\begin_layout Standard
"The boolean base data type is exactly what you expect: a pre-defined enumerated
 data type with values True and False.
 To define a domain-specific data type based on a boolean base type, write:
 data type <name> is boolean (default value is <value>)
\end_layout

\begin_layout Standard
The operations permitted for data elements based on these base types include
 the comparison operations, represented as = (identical in value) and !=
 (not identical in value).
 The result of either comparison yields a data element of base type boolean.
 The logical operations, not, and, & or, are defined in the standard way."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
"The operations permitted for data elements based on these base types include
 the comparison operations, represented as = (identical in value) and !=
 (not identical in value).
 The result of either comparison yields a data element of base type boolean.
 The logical operations, not, and, & or, are defined in the standard way."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"boolean",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"equal", symbol:"=", type:"boolean", result:"boolea
n") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"boolean", result:"b
oolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"logical not", symbol:"not", type:"boolean",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"logical and", symbol:"and", type:"boolean",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"logical or", symbol:"or", type:"boolean",
 result:"boolean") to TYOP class;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Boolean:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Boolean-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Boolean State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many bools from instances of BOOL;
\end_layout

\begin_layout Plain Layout

if (cardinality bools == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   type.name = "boolean";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::BOOLEAN;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of BOOL attempted!");
\end_layout

\begin_layout Plain Layout

   generate BOOL2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

  core.destroy();
\end_layout

\begin_layout Plain Layout

  unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

  delete object instance core;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Composite
\end_layout

\begin_layout Standard
"A type may be composite, but the corresponding attribute must always be
 treated by the domain as a single unit"
\begin_inset CommandInset citation
LatexCommand cite
key "xtUML"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
The operations permitted using data types based on composite are limited
 to equality comparison and assignment to another composite type.
\end_layout

\begin_layout Standard
If individual elements of a composite type are to be operated on within
 the passed-to domain, then they must be sent individually.
 If they need to be treated as a group, then a class must be declared within
 the domain that supports them.
\end_layout

\begin_layout Standard
The operations external to the domain to support these two mechanisms consist
 of ungrouping the data from the composite, making the data available to
 the domain, and then regrouping the processed data.
 NOTE: while this process sounds onerous, the architecture can perform coping
 mechanisms, such as mapping instances of the class in the domain to point
 to memory locations in the composite external to the domain.
 In this case, the whole ungroup, pass-in, and regroup is done automatically
 and the external operation only needs to ensure the sequence occurs without
 interference.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
The operations permitted using data types based on composite are limited
 to equality comparison and assignment to another composite type.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"composite",
 result:"composite") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"equal", symbol:"=", type:"composite", result:"bool
ean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"composite",
 result:"boolean") to TYOP class;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Composite:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Composite-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Composite State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many comps from instances of COMP;
\end_layout

\begin_layout Plain Layout

if (cardinality comps == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   type.name = "composite";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::COMPOSITE;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of COMP attempted!");
\end_layout

\begin_layout Plain Layout

   generate COMP2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

  core.destroy();
\end_layout

\begin_layout Plain Layout

  unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

  delete object instance core;
\end_layout

\begin_layout Plain Layout

end if; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Core
\end_layout

\begin_layout Standard
Core types are defined within the context of the Shlaer-Mellor Method.
 Every Shlaer-Mellor model, adhering to this metamodel, will support these
 types.
 Core types are not intended to be multiply instantiated.
 Each core type is defined only once in the metamodel.
 Specialization of the core types are done through definitions based on
 the core types.
 These definitions are considered domain types, so they aren't modeled in
 this metamodel.
 The enumeration definition is an exception to this rule, as it has a known
 structure.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

type:data_t
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
operator_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one operator related by self->OPER[R419];
\end_layout

\begin_layout Plain Layout

unrelate self from operator across R419;
\end_layout

\begin_layout Plain Layout

select one type related by self->TYPE[R401];
\end_layout

\begin_layout Plain Layout

if (not empty type)
\end_layout

\begin_layout Plain Layout

  type.remove();
\end_layout

\begin_layout Plain Layout

  unrelate type from self across R401;
\end_layout

\begin_layout Plain Layout

  delete object instance type;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

select many udts related by self->DOMD[R402];
\end_layout

\begin_layout Plain Layout

for each udt in udts
\end_layout

\begin_layout Plain Layout

  unrelate self from udt across R402;
\end_layout

\begin_layout Plain Layout

  generate DOMD2:destroy() to udt;
\end_layout

\begin_layout Plain Layout

end for; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Core:destroy()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Domain
\end_layout

\begin_layout Standard
Domain types are unique within the context of the domain.
 Domain types are often also called user-defined types, because they are
 defined by the analyst when modeling the domain.
 Often domain types will have a known name within the subject matter of
 the domain.
\end_layout

\begin_layout Standard
Domain types are formed using a core type as a base.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
domain_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
base_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Domain-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Domain State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

type.name = param.name;
\end_layout

\begin_layout Plain Layout

create object instance domd of DOMD;
\end_layout

\begin_layout Plain Layout

relate domd to type across R401;
\end_layout

\begin_layout Plain Layout

select any mdom from instances of MDOM where selected.name == param.domain;
\end_layout

\begin_layout Plain Layout

relate domd to mdom across R412;
\end_layout

\begin_layout Plain Layout

select many cores from instances of CORE;
\end_layout

\begin_layout Plain Layout

for each core in cores
\end_layout

\begin_layout Plain Layout

  if (core.type == param.coreType)
\end_layout

\begin_layout Plain Layout

    relate core to domd across R402;
\end_layout

\begin_layout Plain Layout

    break;
\end_layout

\begin_layout Plain Layout

  end if;
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one type related by self->TYPE[R401];
\end_layout

\begin_layout Plain Layout

if (not empty type)
\end_layout

\begin_layout Plain Layout

  type.remove();
\end_layout

\begin_layout Plain Layout

  unrelate type from self across R401;
\end_layout

\begin_layout Plain Layout

  delete object instance type;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\begin_layout Plain Layout

select one core related by self->CORE[R402.''is based on''];
\end_layout

\begin_layout Plain Layout

unrelate self from core across R402.''is based on'';
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Duration
\end_layout

\begin_layout Standard
"Similarly, to define a data type that represents duration, write data type
 <data type name> is duration range is from <low limit> to <high limit>
 units are [ year | month | day | hour | minute | second | millisec | microsec
 ] precision is <smallest discriminated value>
\end_layout

\begin_layout Standard
The operations permitted using data types based on time and duration are:
 time := time ± duration duration := duration ± duration duration := duration
 * numeric duration := duration / numeric duration := time - time as well
 as the standard comparisons of < (read as "before"), >, ≤ , and ≥ .
 Each such comparison yields a data element of base type boolean.
 Comparisons are defined only between elements of the same base type."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
"The operations permitted using data types based on ...
 duration are:
\end_layout

\begin_layout Itemize
duration := duration ± duration
\end_layout

\begin_layout Itemize
duration := duration * numeric
\end_layout

\begin_layout Itemize
duration := duration / numeric
\end_layout

\begin_layout Itemize
duration := time - time
\end_layout

\begin_layout Plain Layout
as well as the standard comparisons of < (read as "before"), >, ≤ , and
 ≥ .
 Each such comparison yields a data element of base type boolean.
 Comparisons are defined only between elements of the same base type."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Plain Layout
NOTE: For mixed type operations, conversion operators must be supported.
 The explicit conversion cases are:
\end_layout

\begin_layout Itemize
duration * numeric: duration->numeric result: numeric
\end_layout

\begin_layout Itemize
duration / numeric: duration->numeric result: numeric
\end_layout

\begin_layout Itemize
duration := numeric: numeric->duration
\end_layout

\begin_layout Itemize
duration := time: time->duration
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"duration",
 result:"duration") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"addition", symbol:"+", type:"duration", result:"du
ration") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"subtraction", symbol:"-", type:"duration",
 result:"duration") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"equal", symbol:"=", type:"duration", result:"boole
an") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"duration",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"greater", symbol:">", type:"duration", result:"boo
lean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"lesser", symbol:"<", type:"duration", result:"bool
ean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"greater or equal", symbol:">=", type:"duration",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"lesser or equal", symbol:"<=", type:"duration",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

// It is highly recommended that the architecture handle conversions auto-
\end_layout

\begin_layout Plain Layout

// matically, so the analyst doesn''t have to explicitly add the conversion
 
\end_layout

\begin_layout Plain Layout

// operator.
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"convert to numeric", symbol:"->NUMI", type:"durati
on", result:"numeric") to TYOP class; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Duration:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Duration-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Duration State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many durds from instances of DURD;
\end_layout

\begin_layout Plain Layout

if (cardinality durds == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   type.name = "duration";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::DURATION;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of DURD attempted!");
\end_layout

\begin_layout Plain Layout

   generate DURD2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

  core.destroy();
\end_layout

\begin_layout Plain Layout

  unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

  delete object instance core;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Enumeration
\end_layout

\begin_layout Standard
"If a data type permits a finite set of values, define it as: data type
 <name> is enumerated values are <value 1 >, <value 2 >, .
 .
 .
 <value N > ( default value is <value k > ) 4 as in: data type IC color
 is enumerated values are red, blue, black, green, silver
\end_layout

\begin_layout Standard
The only operations permitted for data elements of an enumerated data type
 are the comparison operations, represented as = (identical in value) and
 != (not identical in value).
 The result of either comparison yields a data element of type boolean."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
["The only operations permitted for data elements of an enumerated data
 type are the comparison operations, represented as = (identical in value)
 and != (not identical in value).
 The result of either comparison yields a data element of type boolean."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"enumeration",
 result:"enumeration") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"equal", symbol:"=", type:"enumeration", result:"bo
olean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"enumeration",
 result:"boolean") to TYOP class;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Enumeration:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Enumeration-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Enumeration State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many enums from instances of ENUM;
\end_layout

\begin_layout Plain Layout

if (cardinality enums == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   type.name = "enumeration";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::ENUMERATION;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of ENUM attempted!");
\end_layout

\begin_layout Plain Layout

   generate ENUM2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

  core.destroy();
\end_layout

\begin_layout Plain Layout

  unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

  delete object instance core;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Enumeration Definition
\end_layout

\begin_layout Standard
An enumeration definition bounds the set of enumeration values allowed when
 an enumeration type is used.
 A variable is declared as an enumeration definition as if the enumeration
 definition was the type.
 This is typical of how most programming languages support the use of enumeratio
ns.
 e.g., <enum keyword> <type name> <enumerator value list> <variable name>
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*name:string
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
type_name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Enumeration Value
\end_layout

\begin_layout Standard
An enumeration value is one of the enumerators that compose an enumeration.
 The uses of enumeration values are constrained by the operations supported
 by the enumeration type.
 An enumeration value can never be identified by just the value name; it
 must always use the enumeration definition name as well.
 e.g., def::value
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

name:string
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

enum_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*id:same_as<Base_Attribute>
\end_layout

\begin_layout Subsection
Instance Reference
\end_layout

\begin_layout Standard
An instance reference is the type to which all object instances must conform.
 This is a core type that says object instances have a common set of operations
 defined for usage.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
The operations permitted for instance reference data types are
\end_layout

\begin_layout Itemize
the comparisons = and != (identical and not identical in value)
\end_layout

\begin_layout Itemize
the set existence checks of empty and not empty.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"instance reference
", result:"instance reference") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"equal", symbol:"=", type:"instance reference",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"instance reference"
, result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"empty", symbol:"empty", type:"instance reference",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not empty", symbol:"not empty", type:"instance
 reference", result:"boolean") to TYOP class;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Instance Reference:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Instance Reference-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Instance Reference State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many irefs from instances of IREF;
\end_layout

\begin_layout Plain Layout

if (cardinality irefs == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   type.name = "instance reference";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::INSTANCE_REFERENCE;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of type IREF attempted!");
\end_layout

\begin_layout Plain Layout

   generate IREF2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

  core.destroy();
\end_layout

\begin_layout Plain Layout

  unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

  delete object instance core;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Numeric
\end_layout

\begin_layout Standard
Numeric is as described below.
 NOTE: The description isn't a model.
 Some seeming attributes of numeric in the description might be modeled
 as their own objects.
 e.g., "units" aren't always used, so cannot be an attribute.
\end_layout

\begin_layout Standard
"If a data type is numeric in nature, write: data type <data type name>
 is numeric (base <N>) range is from <low limit> to <high limit> units are
 <unit symbol> precision is <smallest discriminant> ( default value is <value>
 ) where base N specifies the base of the quantities <low limit>, <high
 limit>, <smallest discriminant> and <value>.
 If base N is omitted, base 10 is assumed.
 Hence: data type ring diameter is numeric range is from 0 to 39 units are
 cm precision is 0.01 data type bit pattern is numeric base 8 range is from
 0 to 177777 units are octal bits precision is 1 Note that the analyst does
 not specify whether a numeric data type will be implemented as an integer
 or a real number.
 This will ultimately be determined by the architecture, based on the native
 types available in the implementation language, the word length of these
 native types, and the range and precision required for the data type.
 As a result, the OOA models of any domain are entirely decoupled from the
 implementation technology, thereby maximizing the potential for reuse across
 a wide range of platforms and implementation languages.
\end_layout

\begin_layout Standard
The operations permitted for numeric data types are: - the standard arithmetic
 operations +, -, * (multiplication), / (division), %% (division modulo
 N), and ** (exponentiation).
 The result of such an operation is again of base type numeric.
 - the standard arithmetic comparisons of = , != , <, >, <= , and >= .
 The result of such a comparison yields a data element of base type boolean."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
Keyword A keyword is a special processing directive.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
"the standard arithmetic operations +, -, * (multiplication), / (division),
 %% (division modulo N), and ** (exponentiation).
 The result of such an operation is again of base type numeric.
 the standard arithmetic comparisons of = , != , <, >, <= , and >=.
 The result of such an operation is of base type boolean."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"numeric",
 result:"numeric") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"addition", symbol:"+", type:"numeric", result:"num
eric") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"subtraction", symbol:"-", type:"numeric",
 result:"numeric") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"multiplication", symbol:"*", type:"numeric",
 result:"numeric") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"division", symbol:"/", type:"numeric", result:"num
eric") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"modulo", symbol:"%%", type:"numeric", result:"nume
ric") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"exponentiation", symbol:"**", type:"numeric",
 result:"numeric") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"equal", symbol:"=", type:"numeric", result:"boolea
n") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"numeric", result:"b
oolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"greater", symbol:">", type:"numeric", result:"bool
ean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"lesser", symbol:"<", type:"numeric", result:"boole
an") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"greater or equal", symbol:">=", type:"numeric",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"lesser or equal", symbol:"<=", type:"numeric",
 result:"boolean") to TYOP class;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Numeric:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Numeric-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Numeric State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Responsible for instantiating this core data type and all operations associated
 with it.
 
\end_layout

\begin_layout Plain Layout
NOTE: At the time of this writing, core data types are never expected to
 be deleted, as deleting a core type would require deletion of all user
 data types based on the core type and all attributes and synchronous functional
ity ultimately based on the core type.
 There is no logical default value to use as a fall back.
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many numis from instances of NUMI;
\end_layout

\begin_layout Plain Layout

if (cardinality numis == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   type.name = "numeric";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::NUMERIC;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of NUMI attempted!");
\end_layout

\begin_layout Plain Layout

   generate NUMI2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Responsible for instantiating this core data type and all operations associated
 with it.
 
\end_layout

\begin_layout Plain Layout
NOTE: At the time of this writing, core data types are never expected to
 be deleted, as deleting a core type would require deletion of all user
 data types based on the core type and all attributes and synchronous functional
ity ultimately based on the core type.
 There is no logical default value to use as a fall back.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

	core.destroy();
\end_layout

\begin_layout Plain Layout

	unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

	delete object instance core;
\end_layout

\begin_layout Plain Layout

end if; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Operator
\end_layout

\begin_layout Standard
An Operator represents a function that may be defined for a Type.
 Not all Operators will be visible in implementation.
 e.g., an action language may choose to allow automatic conversion from one
 type to another, 5 + "5" = 10.
 In such a case, a string to numeric Operator must be defined as part of
 the instantiation of the metamodel.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*
\begin_inset script superscript

\begin_layout Plain Layout
2
\end_layout

\end_inset

symbol:string "A short, often single character, name to represent an Operator
 in a written expression.
 Common examples are + , - , * , ++ , next , etc."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Description
*name:string "A descriptive name applicable to multiple Types such as add,
 multiply, increment, etc."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
Operator association associates the operator for use in an equation.
\end_layout

\begin_layout Plain Layout
rh_element: The element on the right hand side of the operator.
\end_layout

\begin_layout Plain Layout
lh_element: The element on the left hand side of the operator.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Operator:associate(rh_element:inst_ref, lh_element:inst_ref)
\end_layout

\end_inset


\end_layout

\end_inset


\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select any type related by self->TYPE[R406] where selected.name == param.type;
\end_layout

\begin_layout Plain Layout

select many tyops related by self->TYOP[R406] where selected.type_name ==
 param.type;
\end_layout

\begin_layout Plain Layout

for each tyop in tyops
\end_layout

\begin_layout Plain Layout

	unrelate self from type across R406 using tyop;
\end_layout

\begin_layout Plain Layout

	select one restype related by tyop->TYPE[R415];
\end_layout

\begin_layout Plain Layout

	unrelate restype from tyop across R415;
\end_layout

\begin_layout Plain Layout

	delete object instance tyop;
\end_layout

\begin_layout Plain Layout

end for; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Operator:unassign(type:string)
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Ordinal
\end_layout

\begin_layout Standard
The ordinal core type automatically populated in the metamodel is specified
 as ascending and based upon identifier, because the only known operation
 is for traversing a collection of object instances.
\end_layout

\begin_layout Standard
To support other ordinal uses in a process model, the user must create a
 user-defined ordinal type.
\end_layout

\begin_layout Standard
The below gives more detail on ordinals:
\end_layout

\begin_layout Standard
"Ordinal data types are used to express order, such as first, second, and
 so on.
 However, the subject of ordering is a lot more interesting that just this
 common example; hence the following digression.
\end_layout

\begin_layout Standard
An ordering is always applied to a set of elements.
 The set can be finite or infinite.
 There are two types of orderings to consider.
 The first is the most familiar; it is a complete ordering.
 What this means is that you can express the concept of "before" (represented
 as <) between any two members of the set.
 Hence, 7 is before 26 ( 7 < 26 ).
 A complete ordering has the property of transitivity:
\end_layout

\begin_layout Standard
If A is before B, and B is before C, then A is before C.
\end_layout

\begin_layout Standard
A practical example would be the ordering of the cars that make up a freight
 train.
 Assume we define a first car.
 Then we could pick any two cars and easily determine which one was before
 the other.
 Far more interesting are the partial orderings.
 Consider this sketch of a partial ordering.
 
\end_layout

\begin_layout Standard
A -> B -> C -> D + -> E -> F -> G 
\end_layout

\begin_layout Standard
Using the obvious interpretation, we can say that A < B (A is before B),
 C < D, C < E, and E < F.
 But we cannot say anything about the relationship between D and F: They
 are non-comparable.
 
\end_layout

\begin_layout Standard
Examples of structures that are partially ordered include PERT charts, trees
 used for any purpose, interlock chains, the connectivity of an electric
 grid, and the like.
 All of these can be modeled in complete detail using standard OOA relationships
; for examples see 
\begin_inset CommandInset citation
LatexCommand cite
key "Starr96"
literal "false"

\end_inset

 and Chapter 4 of Shlaer-Mellor Method: The OOA96 Report
\begin_inset CommandInset citation
LatexCommand cite
key "OOA96"
literal "false"

\end_inset

.
 Note, however, that when modeling such a structure, one frequently finds
 it necessary to employ quite a number of ancillary objects (such as root
 node, parent node, child node, and leaf node) together with a significant
 set of relationships all required to express a generally well-known concept.
 While this can be quite satisfying when one is in a purist frame of mind,
 the pragmatist points out that such constructions are often of limited
 value, obscuring, as they can, the true purpose of the model.
 This becomes particularly pertinent when constructing models of an architecture
, where ordering is a particularly prominent theme (see The Timepoint Architectu
re chapter).
 Hence we have defined the ordinal base data type, leaving it to the judgment
 of the analyst as for when to use an ordinal attribute as opposed to using
 more fully expressive OOA objects and relationships.
\end_layout

\begin_layout Standard
Returning now to the main theme, an ordinal data type is defined by: 
\end_layout

\begin_layout Standard
data type <data type name> is ordinal 
\end_layout

\begin_layout Standard
The operations permitted for ordinal data types are:
\end_layout

\begin_layout Itemize
the comparisons = and != (identical and not identical in value)
\end_layout

\begin_layout Itemize
the comparisons < (read as "before"), >, <= , and >= .
 Each such comparison yields a data element of base type boolean if the
 ordering is complete, and of base type extended boolean if the ordering
 is partial."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\begin_inset Newline newline
\end_inset

NOTE: This metamodel doesn't support an extended boolean type, so a comparison
 of partial ordering will always yield false.
 
\end_layout

\begin_layout Itemize
the set existence checks of empty and not empty"
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
Ordering implies a direct path where one can follow the path in any direction
 to determine what is before and what is after.
 Changing direction isn't permitted (i.e., taking another path), and traversing
 multiple paths is another operation (e.g., get number of items after C on
 path 1 yields 1 (D), and get number of items after C on path 2 yields 3
 (E, F, G); the total number of items after C is 4 (result 1 + result 2).
 
\end_layout

\begin_layout Standard
Any comparison operations have to be done on the same path, so an "illegal"
 comparison across two paths will yield a false.
 The analyst must be cautioned about this rule, or the tool implementer
 could make such comparisons result in an error.
 This rule on paths obviates the need for an "extended boolean" as described
 in 
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset

.
\end_layout

\begin_layout Standard
Ordering is done based upon a common index value.
 This means that all the members of the ordinal must be of the same type,
 but not all types can be part of an ordinal.
 e.g., composites, booleans, ordinals, and enumerations.
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
direction:integer Direction of ordering is either ascending or descending.
 The direction can be dynamically changed in the process models.
 A loop operation on the ordinal will follow the set direction.
\end_layout

\begin_layout Description
order_specifier:string The order specifier attribute determines the basis
 of the ordering.
 The order specifier can be an object attribute, if the ordinal is composed
 of objects, a meta-attribute, e.g., identifier, name, etc., common ordering
 based upon data type, i.e., numeric +/- 1, alphabetical for strings, etc.,
 or physical placement.
 (A TBD symbol or keyword will be defined to indicate placement.) Placement
 is to be considered ordered by a means external to the data.
 e.g., an array.
 A placement ordinal will have means of inserting, moving, and removing
 ordered elements.
 Placement ordinals will also have associated marks, so placement can be
 based on platform considerations.
 e.g., memory location, timestamp, etc.
 All ordinals will have the ability to add and remove elements.
 The order specifier can be dynamically changed in the process models.
 
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
The operations permitted for instance reference data types are
\end_layout

\begin_layout Itemize
the comparisons = and != (identical and not identical in value)
\end_layout

\begin_layout Itemize
the set existence checks of empty and not empty.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"ordinal",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"join", symbol:"+", type:"ordinal", result:"ordinal
") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"equal", symbol:"=", type:"ordinal", result:"boolea
n") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"ordinal", result:"b
oolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"empty", symbol:"empty", type:"ordinal", result:"bo
olean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not empty", symbol:"not empty", type:"ordinal",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"numeric",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"numeric",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"symbolic",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"symbolic",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"boolean",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"boolean",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"arbitrary",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"arbitrary",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"duration",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"duration",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"time",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"time",
 result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"instance
 reference", result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"instance
 reference", result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"function
 reference", result:"ordinal") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"function
 reference", result:"ordinal") to TYOP class;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Ordinal:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Ordinal-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Ordinal State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many ordds from instances of ORDD;
\end_layout

\begin_layout Plain Layout

if (cardinality ordds == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   type.name = "ordinal";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::ORDINAL;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of ORDD attempted!");
\end_layout

\begin_layout Plain Layout

   generate ORDD2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

  core.destroy();
\end_layout

\begin_layout Plain Layout

  unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

  delete object instance core;
\end_layout

\begin_layout Plain Layout

end if; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Relationship Instance Reference
\end_layout

\begin_layout Standard
A relationship instance reference is the type to which all relationship
 instances must conform.
 This is a core type that says relationship instances have a common set
 of operations defined for usage.
\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
The operations permitted for instance reference data types are
\end_layout

\begin_layout Itemize
the comparisons = and != (identical and not identical in value)
\end_layout

\begin_layout Itemize
the set existence checks of empty and not empty.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"relationship
 instance reference", result:"relationship instance reference") to TYOP
 class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"equal", symbol:"=", type:"relationship instance
 reference", result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"relationship
 instance reference", result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"empty", symbol:"empty", type:"relationship
 instance reference", result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not empty", symbol:"not empty", type:"relationship
 instance reference", result:"boolean") to TYOP class;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Relationship Instance Reference:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Relationship Instance Reference-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Relationship Instance State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many rrefs from instances of RREF;
\end_layout

\begin_layout Plain Layout

if (cardinality rrefs == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   type.name = "relationship instance reference";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::RELATIONSHIP_INSTANCE_REFERENCE;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of type RREF attempted!");
\end_layout

\begin_layout Plain Layout

   generate RREF2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

  core.destroy();
\end_layout

\begin_layout Plain Layout

  unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

  delete object instance core;
\end_layout

\begin_layout Plain Layout

end if; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Symbolic
\end_layout

\begin_layout Standard
"For data elements that have the nature of names, we need to be able to
 define symbolic data types: data type <data type name> is symbolic length
 is (from <minimum number of characters> to ) <maximum number of characters>
 (default value is <character string>) The analyst specifies the maximum
 and minimum number of characters required based on his or her knowledge
 of the longest and shortest plausible values.
 Hence: data type gas name is symbolic length is from 2 to 15 default value
 is Helium
\end_layout

\begin_layout Standard
The operations defined for symbolic data types are: - concatenate (represented
 as +); the result of concatenation is a data element of base type symbolic.
 - comparison for identical value, represented as = (identical in value)
 and != (not identical in value).
 The result of such a comparison yields a data element of base type boolean.
 - comparison for position in a collating sequence[5], represented as <
 (before), > (after), <= (before or identical), and >= (identical or after).
 The result of such a comparison yields a data element of base type boolean.
\end_layout

\begin_layout Standard
[5] A collating sequence prescribes the order of all the characters in a
 specified character set, typically including letters, numbers, and punctuation
 marks.
 Collating sequences are defined in the implementation environment, and
 may vary from country to country depending on the concept of "alphabetical
 order" and the repertoire of characters or symbols used in the natural
 language."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
"The operations defined for symbolic data types are:
\end_layout

\begin_layout Itemize
concatenate (represented as +); the result of concatenation is a data element
 of base type symbolic.
\end_layout

\begin_layout Itemize
comparison for identical value, represented as = (identical in value) and
 != (not identical in value).
 The result of such a comparison yields a data element of base type boolean.
\end_layout

\begin_layout Itemize
comparison for position in a collating sequence[see definition below], represent
ed as < (before), > (after), <= (before or identical), and >= (identical
 or after).
 The result of such a comparison yields a data element of base type boolean.
\end_layout

\begin_layout Plain Layout
A collating sequence prescribes the order of all the characters in a specified
 character set, typically including letters, numbers, and punctuation marks.
 Collating sequences are defined in the implementation environment, and
 may vary from country to country depending on the concept of "alphabetical
 order" and the repertoire of characters or symbols used in the natural
 language."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"symbolic",
 result:"symbolic") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"concatenate", symbol:"+", type:"symbolic",
 result:"symbolic") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"equal", symbol:"=", type:"symbolic", result:"boole
an") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"symbolic",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"greater", symbol:">", type:"symbolic", result:"boo
lean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"lesser", symbol:"<", type:"symbolic", result:"bool
ean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"greater or equal", symbol:">=", type:"symbolic",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"lesser or equal", symbol:"<=", type:"symbolic",
 result:"boolean") to TYOP class;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Symbolic:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Symbolic-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Symbolic State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many symds from instances of SYMD;
\end_layout

\begin_layout Plain Layout

if (cardinality symds == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   type.name="symbolic";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::SYMBOLIC;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of SYMD attempted!");
\end_layout

\begin_layout Plain Layout

   generate SYMD2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

  core.destroy();
\end_layout

\begin_layout Plain Layout

  unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

  delete object instance core;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Time
\end_layout

\begin_layout Standard
"To define a data type that represents calendar-clock time, write: data
 type <data type name> is time range is from <year-mon-day> (<hour:min:sec
 >) to <year-mon-day> (<hour:min:sec >) precision is <smallest discriminated
 value> [ year | month | day | hour | minute | second | millisec | microsec
 ]
\end_layout

\begin_layout Standard
The operations permitted using data types based on time and duration are:
 time := time ± duration duration := duration ± duration duration := duration
 * numeric duration := duration / numeric duration := time - time as well
 as the standard comparisons of < (read as "before"), >, ≤ , and ≥ .
 Each such comparison yields a data element of base type boolean.
 Comparisons are defined only between elements of the same base type."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
current_state:state<State_Model>
\end_layout

\begin_layout Description
*name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
"The operations permitted using data types based on time ...
 are: 
\end_layout

\begin_layout Itemize
time := time ± duration as well as the standard comparisons of < (read as
 "before"), >, ≤ , and ≥ .
 Each such comparison yields a data element of base type boolean.
 Comparisons are defined only between elements of the same base type."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Itemize
time := time ± time
\end_layout

\begin_layout Plain Layout
NOTE: For mixed type operations, conversion operators must be supported.
 The explicit conversion cases are: 
\end_layout

\begin_layout Itemize
duration := time: time->duration
\begin_inset Newline newline
\end_inset

NOTE: The architecture should add boundary checks on this conversion, as
 durations are often expressed in (e.g.,) microseconds.
 The system needs to be able to support very large numbers if values are
 more than one hour.
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

generate TYOP_A1:create(name:"assignment", symbol:":=", type:"time", result:"tim
e") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"addition", symbol:"+", type:"time", result:"time")
 to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"subtraction", symbol:"-", type:"time", result:"tim
e") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"equal", symbol:"=", type:"time", result:"boolean")
 to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"time", result:"bool
ean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"greater", symbol:">", type:"time", result:"boolean
") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"lesser", symbol:"<", type:"time", result:"boolean"
) to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"greater or equal", symbol:">=", type:"time",
 result:"boolean") to TYOP class;
\end_layout

\begin_layout Plain Layout

generate TYOP_A1:create(name:"lesser or equal", symbol:"<=", type:"time",
 result:"boolean") to TYOP class; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Time:generateSupportedOperators()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Time-Instance State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Time State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Only create if type doesn''t exist
\end_layout

\begin_layout Plain Layout

select many timds from instances of TIMD;
\end_layout

\begin_layout Plain Layout

if (cardinality timds == 1)
\end_layout

\begin_layout Plain Layout

   create object instance type of TYPE;
\end_layout

\begin_layout Plain Layout

   create object instance core of CORE;
\end_layout

\begin_layout Plain Layout

   relate type to core across R401;
\end_layout

\begin_layout Plain Layout

   type.name = "time";
\end_layout

\begin_layout Plain Layout

   core.type = data_t::TIME;
\end_layout

\begin_layout Plain Layout

   relate core to self across R403;
\end_layout

\begin_layout Plain Layout

   self.generateSupportedOperators();
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

   LOG::LogFailure(message:"Multiple creation of TIMD attempted!");
\end_layout

\begin_layout Plain Layout

   generate TIMD2:destroy to self;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select one core related by self->CORE[R403];
\end_layout

\begin_layout Plain Layout

if (not empty core)
\end_layout

\begin_layout Plain Layout

  core.destroy();
\end_layout

\begin_layout Plain Layout

  unrelate core from self across R403;
\end_layout

\begin_layout Plain Layout

  delete object instance core;
\end_layout

\begin_layout Plain Layout

end if; 
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Destroying
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Type
\end_layout

\begin_layout Standard
"A Type is a named finite or infinite set of values."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\end_layout

\begin_layout Standard
"RULE: All data elements that appear in the OOA models of a domain must
 be typed."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
*name:string Types are uniquely identified by a string designation.
 The type name is unique within its context.
\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select many operators related by self->OPER[R406];
\end_layout

\begin_layout Plain Layout

for each operator in operators
\end_layout

\begin_layout Plain Layout

  operator.unassign(type:self.name);
\end_layout

\begin_layout Plain Layout

  select any type related by operator->TYPE[R406.''is used in a context establish
ed by''];
\end_layout

\begin_layout Plain Layout

  if (empty type)
\end_layout

\begin_layout Plain Layout

    delete object instance operator;
\end_layout

\begin_layout Plain Layout

  end if;
\end_layout

\begin_layout Plain Layout

end for;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void Type:remove()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Typed Operator
\end_layout

\begin_layout Standard
"An Operator is polymorphic in that it may be applied to multiple Types."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset

 The Typed Operator is the mapping of a Type to an Operator.
 The context of the result of the operation is the same as the context of
 the Typed Operator chosen.
 This implies precedence must be built into the process model, if automatic
 type conversion is desired, because the result of e.g., 5 + "5" is different
 if '+' is a string operator vs a numeric operator.
 (This also requires that the corresponding conversion operator is defined.)
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
definition:boolean "This is a precise specification of the processing required
 to transform the Operands to produce either a return value or an update
 result, depending on the Typed Operator specialization."
\begin_inset CommandInset citation
LatexCommand cite
key "miUML"
literal "false"

\end_inset


\begin_inset Newline newline
\end_inset

NOTE: miUML has this typed as "psuedocode", because of not yet having an
 "Operator definition language".
 In BridgePoint, it's declared as a derived type, so OAL can be used to
 define the operator.
\begin_inset Newline newline
\end_inset


\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

self.definition=false;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Typed Operator:defined Derived Attribute
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
*result_type_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*type_name:same_as<Base_Attribute>
\end_layout

\begin_layout Description
*operation_name:same_as<Base_Attribute>
\end_layout

\begin_layout Subsubsection
Object State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset Graphics
	filename images/shlaer-mellor-metamodel-metamodel-Shlaer-Mellor Metamodel-Type-Typed Operator-Class State Machine.png
	scale 30

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Typed Operator State Model
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

select any result from instances of TYPE where selected.name == rcvd_evt.result;
\end_layout

\begin_layout Plain Layout

if (empty result)
\end_layout

\begin_layout Plain Layout

  // Wait 10 milliseconds and retry, since type creation is asynchronous.
 This 
\end_layout

\begin_layout Plain Layout

  // code could launch a creation event, but the responsibility lies outside
 of 
\end_layout

\begin_layout Plain Layout

  // this process.
 This process only has to understand the asynchronous nature 
\end_layout

\begin_layout Plain Layout

  // of type creation and acommodate it.
\end_layout

\begin_layout Plain Layout

  create event instance recreate of TYOP_A1:create(name:rcvd_evt.name, symbol:rcv
d_evt.symbol, type:rcvd_evt.type, result:rcvd_evt.result) to TYOP class;
\end_layout

\begin_layout Plain Layout

  bridge retry_timer = TIM::timer_start(microseconds:10000, event_inst:recreate)
;
\end_layout

\begin_layout Plain Layout

else
\end_layout

\begin_layout Plain Layout

  select any operator from instances of OPER where (selected.name == rcvd_evt.name
) and (selected.symbol == rcvd_evt.symbol);
\end_layout

\begin_layout Plain Layout

  if (empty operator)
\end_layout

\begin_layout Plain Layout

    create object instance operator of OPER;
\end_layout

\begin_layout Plain Layout

    operator.name = rcvd_evt.name;
\end_layout

\begin_layout Plain Layout

    operator.symbol = rcvd_evt.symbol;
\end_layout

\begin_layout Plain Layout

  end if;
\end_layout

\begin_layout Plain Layout

  select any type from instances of TYPE where selected.name == rcvd_evt.type;
\end_layout

\begin_layout Plain Layout

  create object instance typed_op of TYOP;
\end_layout

\begin_layout Plain Layout

  relate operator to type across R406 using typed_op;
\end_layout

\begin_layout Plain Layout

  relate typed_op to result across R415;
\end_layout

\begin_layout Plain Layout

  // For assignment operators, make them the required operator if requestor
 is 
\end_layout

\begin_layout Plain Layout

  // a core type (which it probably is).
\end_layout

\begin_layout Plain Layout

  if (operator.name == "assignment")
\end_layout

\begin_layout Plain Layout

     select one core related by type->CORE[R401];
\end_layout

\begin_layout Plain Layout

     if (not empty core)
\end_layout

\begin_layout Plain Layout

        relate core to operator across R419;
\end_layout

\begin_layout Plain Layout

     end if;
\end_layout

\begin_layout Plain Layout

  end if;
\end_layout

\begin_layout Plain Layout

end if;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
Creating
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Section
Relationship Descriptions
\end_layout

\begin_layout Description
R401 Data types in OOA are all based on a set of core data types defined
 by the Shlaer-Mellor method, but the method allows the types to be further
 constrained to meet the requirements of the domain being modeled.
\end_layout

\begin_layout Description
R402 A domain data type is based on one of the core data types.
 A domain data type is used to further constrain the core types to meet
 the requirements of the domain more closely.
\end_layout

\begin_layout Description
R403 The core data type is subtyped into all the supported core types defined
 by the Shlaer-Mellor method.
\end_layout

\begin_layout Description
R406 "An Operator has no utility unless it is relevant to at least one Type.
 The same Operator may be used with many Types making it polymorphic.
\begin_inset Newline newline
\end_inset

A Type has no utility without at least one Operator.
 Since assignment and equality must be defined for all Types, there should
 at the very least be two Operators defined for any given Type."
\begin_inset CommandInset citation
LatexCommand cite
key "OOAData"
literal "false"

\end_inset


\begin_inset Newline newline
\end_inset

A Domain Type can have its own defined operators, or it can just make use
 of its associated Core Type operators, so "Type" in the second paragraph
 quoted above should be read as "Core Type" with respect to this metamodel.
 This makes the relationship conditional on the Operator end.
\end_layout

\begin_layout Description
R412 A domain type is defined and unique within a modeled domain.
 The modeled domain encapsulates the definition of the domain type, such
 that the domain type can only be used within the modeled domain.
\end_layout

\begin_layout Description
R415 A typed operator will result in a type that can differ from it's assigned
 type.
 A type can be a result type for many typed operators.
\end_layout

\begin_layout Description
R416 Enumeration definitions are typed as an enumeration, but the enumeration
 type can exist without any enumeration definitions.
\end_layout

\begin_layout Description
R417 An Instance Reference types an Object Instance used as a value.
 Many Object Instances can be typed as Instance Reference.
\end_layout

\begin_layout Description
R419 A core type always has at least one operator defined for it, but an
 operator might be defined for a domain type instead of a core type.
\begin_inset Newline newline
\end_inset

The assignment operator would be good to establish this relationship, as
 all types have an assignment operator.
 i.e., what good is a datatype that can't be assigned?
\end_layout

\begin_layout Description
R420 An enumeration value is assigned to one enumeration definition, and
 an enumeration has one or more enumeration values.
\end_layout

\begin_layout Description
R421 A Relationship Instance Reference types a Relationship Instance used
 as a value.
 Many Relationship Instances can be typed as a Relationship Instance Reference.
\end_layout

\begin_layout Description
R422 An Accessor Reference types an Accessor Instance used as a value.
 Many Accessor Instances can be typed as Accessor Reference.
\end_layout

\begin_layout Description
R423 A Keyword types a Keyword Instance used as a value.
 Many Keyword Instances can be typed as a Keyword.
\end_layout

\begin_layout Section
Domain Services
\end_layout

\begin_layout Subsection
Provided Services
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

// Each core type is responsible for it''s own creation.
\end_layout

\begin_layout Plain Layout

generate BOOL1:create() to BOOL creator;
\end_layout

\begin_layout Plain Layout

generate COMP1:create() to COMP creator;
\end_layout

\begin_layout Plain Layout

generate DURD1:create() to DURD creator;
\end_layout

\begin_layout Plain Layout

generate TIMD1:create() to TIMD creator;
\end_layout

\begin_layout Plain Layout

generate NUMI1:create() to NUMI creator;
\end_layout

\begin_layout Plain Layout

generate ARID1:create() to ARID creator;
\end_layout

\begin_layout Plain Layout

generate ENUM1:create() to ENUM creator;
\end_layout

\begin_layout Plain Layout

generate ORDD1:create() to ORDD creator;
\end_layout

\begin_layout Plain Layout

generate SYMD1:create() to SYMD creator;
\end_layout

\begin_layout Plain Layout

generate IREF1:create() to IREF creator;
\end_layout

\begin_layout Plain Layout

generate AREF1:create() to AREF creator;
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void createCoreTypes()
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Object Model Bridges
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void ()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Process Model Bridges
\end_layout

\begin_layout Standard
Incoming bridges for creating model elements of the Process Model subsystem
 as metamodel instances.
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void ()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Dynamic Model Bridges
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void ()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Data Model Bridges
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
void ()
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Section
Domain Datatypes
\end_layout

\begin_layout Standard
User defined data types for the operation of the Shlaer-Mellor Metamodel
 domain.
\end_layout

\begin_layout Description
data_t An enumeration of the core data types defined in the metamodel.
\end_layout

\begin_deeper
\begin_layout Description
ACCESSOR_REFERENCE A data type that represents a handle to an accessor instance.
 
\end_layout

\begin_layout Description
ARBITRARY A data type that acts as a unique specifier.
 
\end_layout

\begin_layout Description
BOOLEAN A data type that can only take one of two values.
 e.g., true or false
\end_layout

\begin_layout Description
COMPOSITE An unordered grouping of data.
 e.g., the struct type in C
\end_layout

\begin_layout Description
DURATION A specified period in units of time.
\end_layout

\begin_layout Description
ENUMERATION A data type that represents a finite set of unique values, specified
 explicitly.
\end_layout

\begin_layout Description
INSTANCE_REFERENCE A data type that represents a handle to a single instantiatio
n of an object.
\end_layout

\begin_layout Description
KEYWORD Data that belongs to the set of special processing directives, that
 should not be defined as variable names.
\end_layout

\begin_layout Description
NUMERIC A data type used to express some number.
 i.e., real, integer, ...
\end_layout

\begin_layout Description
ORDINAL A data type used to express order.
 e.g., an array
\end_layout

\begin_layout Description
RELATIONSHIP_INSTANCE_REFERENCE A data type that represents a handle to
 a single instantiation of a relationship.
\end_layout

\begin_layout Description
SYMBOLIC A data type that represents a non-empty finite set of symbols (e.g.,
 an alphabet), combined and used to convey meaning.
 Typically known as a string in various programming languages.
\end_layout

\begin_layout Description
TIME A calendar-clock time data type.
\end_layout

\end_deeper
\begin_layout Description
creationResult_t The creation result type is used in conjunction with creating
 a Shlaer-Mellor domain model to verify it is compatible with the metamodel.
 The result enumerator directs the verifier toward further action.
\end_layout

\begin_deeper
\begin_layout Description
SUCCESS Creation of model element satisfies all constraints in the metamodel.
 No further action recommended for the verifier.
\end_layout

\begin_layout Description
DUPLICATE A duplicate of the specified model element has already been created
 for this domain.
 The result is a new copy isn't created, and a log of the failure will be
 made.
\begin_inset Newline newline
\end_inset

The verifier can ignore this result, if duplication is expected in its operation
, or further action can be taken.
\begin_inset Newline newline
\end_inset

If this occurs when creating a domain, then it could be that an old verification
 attempt is still in existence.
\end_layout

\begin_layout Description
FAILURE This means the creation resulted in a failure with respect to constraint
s in the metamodel.
 The result is some elements might have been created in the metamodel, and
 a log entry of the constraint failure is made.
\begin_inset Newline newline
\end_inset

This result is to be expected at certain points of model verification.
 e.g., add_domain will fail due to the constraint that a domain model must
 contain at least one object, but you also can't create an object without
 a domain.
 In unexpected cases, the log entry should be consulted before proceeding.
\end_layout

\end_deeper
\begin_layout Description
state_t An enumeration of the possible purposes for a state in a state model.
\end_layout

\begin_deeper
\begin_layout Description
CREATION A creation state is a start state that causes instance creation
 upon entry.
\end_layout

\begin_layout Description
DELETION A deletion state is a state that causes instance deletion upon
 exit.
\end_layout

\begin_layout Description
MIDDLE A middle state is a state that isn't a start, creation, or deletion
 state.
\end_layout

\begin_layout Description
START A start state is the residing state upon state machine creation.
\end_layout

\end_deeper
\begin_layout Description
transition_t An enumeration of the types of entries that are added to cells
 of a state transition table (STT).
 "the STT is a far superior representation for verifying the completeness
 of and consistency of the transition rules.
 Filling out the STT requires you to consider the effect of every event-state
 combination."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_deeper
\begin_layout Description
CANNOT_HAPPEN The transition results in an "can't happen"."If an event cannot
 happen when the instance is in a particular state, record the fact by entering
 can't happen in the appropriate cell [of the state transition table]."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Description
EVENT_IGNORED The transition results in an "event ignored"."If an object
 refuses to respond to a particular event when it is in a certain state,
 enter event ignored in the appropriate cell [of the state transition table]."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\begin_layout Description
NEW_STATE The transition results in a new state.
 "The cell [of the state transition table] is filled in with the name of
 the new state that results when an instance in the state specified by the
 row receives the event specified by the column."
\begin_inset CommandInset citation
LatexCommand cite
key "OL:MWS"
literal "false"

\end_inset


\end_layout

\end_deeper
\begin_layout Part
Templates
\end_layout

\begin_layout Chapter
Subsystem Template
\end_layout

\begin_layout Standard
<description of subsystem>
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
<picture of object model for subsystem>NOTE: Scale to 70% page width.
\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
<name> Subsystem Diagram
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Section
Object and Attribute Descriptions
\end_layout

\begin_layout Standard
<see 
\begin_inset CommandInset ref
LatexCommand formatted
reference "chap:Object-and-Attribute"
plural "false"
caps "false"
noprefix "false"

\end_inset

>
\end_layout

\begin_layout Section
Relationship Descriptions
\end_layout

\begin_layout Standard
<see 
\begin_inset CommandInset ref
LatexCommand formatted
reference "chap:Relationship-Template"
plural "false"
caps "false"
noprefix "false"

\end_inset

>
\end_layout

\begin_layout Chapter
\begin_inset CommandInset label
LatexCommand label
name "chap:Object-and-Attribute"

\end_inset

Object and Attribute List Template
\begin_inset Foot
status open

\begin_layout Plain Layout
Imported objects (from another subsystem) aren't included.
\end_layout

\end_inset


\end_layout

\begin_layout Subsection
<Object Name>
\end_layout

\begin_layout Subsubsection
Attributes
\end_layout

\begin_layout Description
[*]
\begin_inset Foot
status open

\begin_layout Plain Layout
Optional asterisk to indicate identifier.
 Additional identifiers should have a superscript number on the right side
 of the asterix.
 There shouldn't be a space between asterix and name.
\end_layout

\end_inset

<name>:<type> <description>
\end_layout

\begin_layout Standard
[Derived attributes]
\begin_inset Float algorithm
placement H
wide false
sideways false
status open

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

<action language>
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
<return type> <object>:<operation name>(<parameter name>:<type>[, \SpecialChar ldots
])
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Relational Attributes
\end_layout

\begin_layout Description
[*]<name>:<relationship
\begin_inset space ~
\end_inset

number> [description]
\begin_inset Foot
status collapsed

\begin_layout Plain Layout
Descriptions for relational attributes are optional and assumed to be the
 same as the actual attribute.
 They can be repeated here, or used to describe unique characteristics of
 the relational attribute in this object.
\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Operations
\end_layout

\begin_layout Standard
\begin_inset Float algorithm
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
[Description]
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

<action language>
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
<return type> <object>:<operation name>(<parameter name>:<type>[, \SpecialChar ldots
])
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Instance State Model
\end_layout

\begin_layout Standard
\begin_inset Float figure
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
<state model graphics>NOTE: Scale graphics to 30%.
\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
<object> State Model
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Description
<state
\begin_inset space ~
\end_inset

name> 
\begin_inset Float algorithm
placement H
wide false
sideways false
status collapsed

\begin_layout Plain Layout
[Description]
\end_layout

\begin_layout Plain Layout
\begin_inset listings
inline false
status open

\begin_layout Plain Layout

<action language>
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout
\begin_inset Caption Standard

\begin_layout Plain Layout
<state name>
\end_layout

\end_inset


\end_layout

\begin_layout Plain Layout

\end_layout

\end_inset


\end_layout

\begin_layout Chapter
\begin_inset CommandInset label
LatexCommand label
name "chap:Relationship-Template"

\end_inset

Relationship Template
\end_layout

\begin_layout Description
R<number> <description>
\end_layout

\begin_layout Bibliography
\begin_inset CommandInset bibitem
LatexCommand bibitem
key "OOSA:MWD"
literal "false"

\end_inset

Object-Oriented Systems Analysis: Modeling the World in Data.
 Sally Shlaer and Stephen J.
 Mellor.
 1988.
 Prentice-Hall, Inc.
 ISBN-13: 978-0136290230
\end_layout

\begin_layout Bibliography
\begin_inset CommandInset bibitem
LatexCommand bibitem
key "OL:MWS"
literal "false"

\end_inset

Object Lifecycles: Modeling the World in States.
 Sally Shlaer and Stephen J.
 Mellor.
 1992.
 Prentice-Hall, Inc.
 ISBN-13: 978-0136299400
\end_layout

\begin_layout Bibliography
\begin_inset CommandInset bibitem
LatexCommand bibitem
key "xtUML"
literal "false"

\end_inset

Executable UML: A Foundation for Model-driven Architecture.
 Stephen J.
 Mellor and Marc J.
 Balcer.
 2002.
 Addison-Wesley Professional.
 ISBN-13: 978-0201748048.
\end_layout

\begin_layout Bibliography
\begin_inset CommandInset bibitem
LatexCommand bibitem
key "Starr96"
literal "false"

\end_inset

How to Build Shlaer-Mellor Object Models.
 Leon Starr.
 1996.
\end_layout

\begin_layout Bibliography
\begin_inset CommandInset bibitem
LatexCommand bibitem
key "OOA96"
literal "false"

\end_inset

OOA '96.
 Sally Shlaer and Neil Lang.
 1996.
 Prentice-Hall, Inc.
 ISBN:0-13-207663-2
\end_layout

\begin_layout Bibliography
\begin_inset CommandInset bibitem
LatexCommand bibitem
key "OOAData"
literal "false"

\end_inset


\begin_inset CommandInset href
LatexCommand href
name "Data Types in OOA"
target "https://xtuml.org/wp-content/uploads/2015/10/Data-Types-in-OOA.pdf"
literal "false"

\end_inset

.
 Sally Shlaer and Stephen J.
 Mellor.
\end_layout

\begin_layout Bibliography
\begin_inset CommandInset bibitem
LatexCommand bibitem
key "Worm"
literal "false"

\end_inset


\begin_inset CommandInset href
LatexCommand href
name "Bridges and Wormholes"
target "https://xtuml.org/wp-content/uploads/2015/10/Bridges-and-Wormholes.pdf"
literal "false"

\end_inset

.
 Sally Shlaer and Stephen J.
 Mellor.
\end_layout

\begin_layout Bibliography
\begin_inset CommandInset bibitem
LatexCommand bibitem
key "miUML"
literal "false"

\end_inset


\begin_inset CommandInset href
LatexCommand href
name "miUML open source executable uml"
target "https://github.com/modelint/shlaer-mellor-metamodel/tree/main/legacy-miuml"
literal "false"

\end_inset

.
 Leon Starr and Andrew Mangogna.
 
\end_layout

\end_body
\end_document
